diff --git a/All notebooks for Tiles/Debugging Tiling images High Res .ipynb b/All notebooks for Tiles/Debugging Tiling images High Res .ipynb new file mode 100644 index 0000000..5218c15 --- /dev/null +++ b/All notebooks for Tiles/Debugging Tiling images High Res .ipynb @@ -0,0 +1,1288 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:36:23.324696: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-12 16:36:23.337494: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-12 16:36:23.350461: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-12 16:36:23.354323: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-12 16:36:23.365483: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-12 16:36:23.986489: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:36:27.935214: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 78643 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-12 16:36:27.936736: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79070 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-12 16:36:27.938107: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + " \n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and pad if necessary\n", + " flat_centers = []\n", + " for img_centers in centers:\n", + " for tile_centers in img_centers:\n", + " # Convert tile_centers to a list of tuples to handle padding consistently\n", + " tile_centers = list(tile_centers)\n", + " if len(tile_centers) == 0:\n", + " tile_centers = [(0, 0)] * max_hits_per_tile\n", + " else:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " tile_centers = tile_centers[:max_hits_per_tile] + [(0, 0)] * (max_hits_per_tile - len(tile_centers))\n", + "\n", + " # Flatten each (x, y) hit into a single list\n", + " flat_centers.append([coord for hit in tile_centers for coord in hit])\n", + "\n", + " flat_centers = np.array(flat_centers)\n", + " return flat_images, flat_centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " \n", + " # Debug: Print the raw centers before any processing\n", + " # print(\"Raw centers for first image:\", centers[0])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " # Debug: Print hits mapped to tiles\n", + " # print(\"Mapped hits per tile for first image:\", hits_per_tile)\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # print(\"Tiled centers before padding:\", tiled_centers[0])\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) # Normalize pixel values\n", + "\n", + " # Normalize coordinates to be within the range [0, 1] based on tile size\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " # Debugging normalized and padded centers\n", + " # print(\"Normalized and padded centers for the first image:\", padded_centers[0])\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + "\n", + " # print(\"Padded centers for first image:\", padded_centers[0])\n", + " return np.array(padded_centers)\n", + " \n", + " \n", + " def reconstruct_image_from_tiles(self, tiles, tile_size, num_tiles_per_row=None):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles).\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image grid.\n", + " If None, it defaults to sqrt of the number of tiles (assuming a square layout).\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " # If num_tiles_per_row is not provided, calculate it as the square root of the number of tiles\n", + " if num_tiles_per_row is None:\n", + " num_tiles_per_row = int(np.sqrt(len(tiles)))\n", + " \n", + " # Initialize an empty array for the reconstructed image\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " \n", + " # Place each tile in the correct position in the reconstructed image\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " \n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Instantiate DataLoader and inspect each step\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/20KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Run normalization and check the data\n", + "normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# Flatten dataset to inspect final values\n", + "train_images_flat, train_centers_flat = flatten_dataset(normalized_images, normalized_centers, tile_size=8, max_hits_per_tile=5)\n", + "# print(\"Sample flattened centers after normalization:\", train_centers_flat[:10])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "import tensorflow as tf\n", + "\n", + "# Split data into training and validation sets\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " # Normalize and flatten data from data loader\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten the dataset\n", + " train_images_flat, train_centers_flat = flatten_dataset(train_images, train_centers, tile_size=8, max_hits_per_tile=5)\n", + " val_images_flat, val_centers_flat = flatten_dataset(val_images, val_centers, tile_size=8, max_hits_per_tile=5)\n", + "\n", + " # Create TensorFlow datasets for training and validation\n", + " batch_size = 1000\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "# Generate the datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_tiles_and_centers(data_loader, img_idx=0):\n", + " \"\"\"\n", + " Visualizes an image alongside its corresponding tiles with hit centers overlaid.\n", + "\n", + " Parameters:\n", + " - data_loader: DataLoader, the instance of DataLoader to access image and center data.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " \"\"\"\n", + " # Get the image and corresponding centers\n", + " image = data_loader.images[img_idx]\n", + " centers = data_loader.centers[img_idx]\n", + " \n", + " # Tile the image and map the centers to the tiles\n", + " tiles, hits_per_tile = data_loader.map_hits_to_tiles(image, centers)\n", + " num_tiles_per_row = int(image.shape[0] / data_loader.tile_size) # Assuming square grid of tiles\n", + "\n", + " # Create a figure grid for the original image and its tiles\n", + " fig, axs = plt.subplots(num_tiles_per_row + 1, num_tiles_per_row, figsize=(12, 12))\n", + " fig.suptitle(\"Original Image and Tiles with Hit Centers\", fontsize=16)\n", + "\n", + " # Display the original image with centers\n", + " axs[0, 0].imshow(image, cmap='gray')\n", + " axs[0, 0].set_title(\"Original Image\")\n", + " axs[0, 0].axis('off')\n", + " for (_, x, y) in centers:\n", + " axs[0, 0].scatter(x, y, color='red', marker='x') # Plot hit centers on original image\n", + "\n", + " # Hide unused axes in the first row, if any\n", + " for j in range(1, num_tiles_per_row):\n", + " axs[0, j].axis('off')\n", + "\n", + " # Plot each tile with centers marked\n", + " for idx, tile in enumerate(tiles):\n", + " row = idx // num_tiles_per_row + 1\n", + " col = idx % num_tiles_per_row\n", + " axs[row, col].imshow(tile, cmap='gray')\n", + " axs[row, col].set_title(f\"Tile {idx}\")\n", + " axs[row, col].axis('on')\n", + " \n", + " # Plot centers within the tile\n", + " for (x, y) in hits_per_tile[idx]:\n", + " axs[row, col].scatter(x, y, color='red', marker='x') # Mark center within tile coordinates\n", + "\n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.9) # Adjust spacing to fit title\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "h = np.random.randint(0, 10000)\n", + "# Call the function with your DataLoader instance\n", + "visualize_image_with_tiles_and_centers(data_loader, img_idx=h) # Visualize the first image with centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:09.971836: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-12 16:38:09.979836: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-12 16:38:09.988683: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731429490.051815 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.054505 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.055210 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.108829 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.108839 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.108967 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.109431 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.109432 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.109609 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.116200 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.116267 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.116282 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.137923 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.138110 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.138119 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.140703 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.140857 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.141081 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.141516 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.141650 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.141833 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.142010 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.142204 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.142356 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.144421 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.144545 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.144625 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.165467 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.165522 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.165596 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.165825 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166300 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166316 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166319 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166898 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166931 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167025 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167299 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167567 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167709 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167781 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.168063 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.168170 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.168435 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.169342 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.170032 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.170202 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.170365 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.172470 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.172588 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.172671 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.175132 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.175169 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.175255 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.177461 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.177503 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.177579 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.180118 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.180294 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.180324 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.182351 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.182390 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.182465 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.182799 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.184109 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.184374 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.184457 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.192245 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.192535 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.192559 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.194659 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.194759 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.194777 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.271231 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.271572 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.271785 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.271998 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.272210 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.272421 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.272634 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.273835 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.274508 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.274729 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.275527 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.275769 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.275991 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.276213 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.278862 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.280147 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.280396 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.280616 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.280845 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.281067 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.281292 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.281519 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.283253 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.283524 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.283758 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.284393 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.284754 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.284973 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.285181 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.285393 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.285609 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.285828 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.286091 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.287632 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.288469 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.288829 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289064 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289430 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289805 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289872 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289883 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.290473 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.290499 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.290519 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291149 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291159 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291177 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291532 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291557 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292069 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292082 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292094 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292538 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292587 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292952 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292970 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.293320 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.293339 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.293672 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.293967 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.294298 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.294531 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.294670 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.294906 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.295091 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.295476 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.295768 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.295863 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.296175 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.296266 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.296568 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.296680 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.297290 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.297308 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.297830 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.298109 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.298328 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.298551 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.298807 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.299035 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.299259 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.303798 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.305834 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.306076 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.308188 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.310642 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.310911 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.311484 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 8/512\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m3s\u001b[0m 8ms/step - loss: 0.0042 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731429490.499477 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.501218 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.501442 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.502603 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.502902 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.503610 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.503606 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.503782 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.503997 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.504435 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.504485 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.504762 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505000 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505219 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505224 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505667 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505671 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505906 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.507560 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.507744 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.507827 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.508018 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.508259 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.508279 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.510499 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.510519 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.510540 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.517426 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.517436 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.517581 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.517880 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518101 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518116 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518549 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518671 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518909 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519028 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519175 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519457 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519724 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519744 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519854 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522064 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522076 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522104 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522633 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522653 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522680 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523152 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523173 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523196 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523668 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523687 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523714 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.524354 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.524374 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.524396 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525064 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525246 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525335 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525572 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525702 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525722 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.527565 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.527559 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.527664 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.529434 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.529468 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.529534 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.529986 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530018 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530104 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530556 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530575 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530648 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.531607 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.531622 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.532194 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.532703 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.532728 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.532825 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.563219 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.563356 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.563690 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.565158 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.565229 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.565641 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.566953 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.566966 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.566983 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.569386 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.569514 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.569531 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.569932 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570170 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570218 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570420 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570624 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570708 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.572433 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.572517 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.572532 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.573887 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.573921 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.573999 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.574538 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.574569 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.574641 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.575382 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.575550 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.575577 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.577450 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.577516 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.577528 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.578458 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.578469 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.578484 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.579391 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.579459 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.579468 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.581152 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.581164 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.581178 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.582030 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.582045 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.582065 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600268 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600405 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600415 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600675 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600957 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600981 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601196 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601464 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601490 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601701 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601946 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601968 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.602181 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.602344 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.602360 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.603426 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.603444 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.603465 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605259 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605274 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605294 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605794 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605814 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605891 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.606518 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.606551 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.606622 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607210 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607242 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607321 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607645 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607874 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607897 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.608094 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.608276 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.608293 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.613912 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.613929 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.613949 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.614791 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.614811 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.614891 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615360 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615377 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615401 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615907 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615924 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615942 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.616558 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.616576 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.616600 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.617288 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.617306 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.617325 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.618245 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.618262 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.618285 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m508/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 9.5214e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:14.644115: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-12 16:38:14.644217: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-12 16:38:14.644340: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731429495.003241 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.003836 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.005808 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.005877 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006148 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006275 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006458 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006636 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006844 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007026 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007206 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007390 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007565 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007742 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007928 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.008046 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.008115 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.008754 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.008941 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009279 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009282 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009401 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009740 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009965 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009969 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010185 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010399 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010535 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010678 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010824 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011158 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011272 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011350 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011709 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011751 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011837 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.012330 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.012634 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.013026 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.013312 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.013634 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.013915 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.014226 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.015564 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.015869 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 10ms/step - loss: 9.4651e-04 - val_loss: 1.0308e-04\n", + "Epoch 2/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:15.608642: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m510/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 7.8845e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:19.905590: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 7.8819e-05 - val_loss: 7.5595e-05\n", + "Epoch 3/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 5.8240e-05 - val_loss: 6.6476e-05\n", + "Epoch 4/50\n", + "\u001b[1m 1/512\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:15\u001b[0m 147ms/step - loss: 2.7314e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:25.170040: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 5.1038e-05 - val_loss: 6.3451e-05\n", + "Epoch 5/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 4.7563e-05 - val_loss: 6.2155e-05\n", + "Epoch 6/50\n", + "\u001b[1m509/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 4.5338e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:38.791413: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 4.5354e-05 - val_loss: 6.1692e-05\n", + "Epoch 7/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 4.3514e-05 - val_loss: 6.1713e-05\n", + "Epoch 8/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 4.1651e-05 - val_loss: 6.1899e-05\n", + "Epoch 9/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 4.0144e-05 - val_loss: 6.2316e-05\n", + "Epoch 10/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 3.8541e-05 - val_loss: 6.3694e-05\n", + "Epoch 11/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 3.6841e-05 - val_loss: 6.4825e-05\n", + "Epoch 12/50\n", + "\u001b[1m 1/512\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:20\u001b[0m 158ms/step - loss: 1.7095e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:39:04.748996: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 3.5457e-05 - val_loss: 6.5911e-05\n", + "Epoch 13/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 3.3885e-05 - val_loss: 6.4922e-05\n", + "Epoch 14/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 3.2363e-05 - val_loss: 6.7580e-05\n", + "Epoch 15/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 3.0586e-05 - val_loss: 6.9048e-05\n", + "Epoch 16/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.9152e-05 - val_loss: 7.1398e-05\n", + "Epoch 17/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 2.7671e-05 - val_loss: 7.4162e-05\n", + "Epoch 18/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.6274e-05 - val_loss: 7.5322e-05\n", + "Epoch 19/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.4991e-05 - val_loss: 7.9788e-05\n", + "Epoch 20/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.4263e-05 - val_loss: 8.2104e-05\n", + "Epoch 21/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.2884e-05 - val_loss: 8.3615e-05\n", + "Epoch 22/50\n", + "\u001b[1m511/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 2.2001e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:40:00.103310: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.2006e-05 - val_loss: 8.4772e-05\n", + "Epoch 23/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.1005e-05 - val_loss: 8.9697e-05\n", + "Epoch 24/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.0036e-05 - val_loss: 9.0401e-05\n", + "Epoch 25/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.9330e-05 - val_loss: 9.3663e-05\n", + "Epoch 26/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.9237e-05 - val_loss: 9.1168e-05\n", + "Epoch 27/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 1.8143e-05 - val_loss: 9.2262e-05\n", + "Epoch 28/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.7307e-05 - val_loss: 9.9012e-05\n", + "Epoch 29/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.7285e-05 - val_loss: 9.7238e-05\n", + "Epoch 30/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.6559e-05 - val_loss: 9.7413e-05\n", + "Epoch 31/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.5807e-05 - val_loss: 1.0160e-04\n", + "Epoch 32/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.5840e-05 - val_loss: 1.0242e-04\n", + "Epoch 33/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.5220e-05 - val_loss: 1.0753e-04\n", + "Epoch 34/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.5398e-05 - val_loss: 1.0038e-04\n", + "Epoch 35/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.4527e-05 - val_loss: 9.7191e-05\n", + "Epoch 36/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.4082e-05 - val_loss: 1.0286e-04\n", + "Epoch 37/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.4120e-05 - val_loss: 1.0302e-04\n", + "Epoch 38/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.4005e-05 - val_loss: 9.9109e-05\n", + "Epoch 39/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.2990e-05 - val_loss: 9.9356e-05\n", + "Epoch 40/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.3678e-05 - val_loss: 1.0106e-04\n", + "Epoch 41/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.3255e-05 - val_loss: 9.8328e-05\n", + "Epoch 42/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.2373e-05 - val_loss: 9.7759e-05\n", + "Epoch 43/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.2102e-05 - val_loss: 9.7576e-05\n", + "Epoch 44/50\n", + "\u001b[1m 1/512\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:20\u001b[0m 158ms/step - loss: 3.9487e-06" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:41:49.887972: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1492e-05 - val_loss: 9.7025e-05\n", + "Epoch 45/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1782e-05 - val_loss: 9.9851e-05\n", + "Epoch 46/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.2226e-05 - val_loss: 9.8247e-05\n", + "Epoch 47/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1213e-05 - val_loss: 9.6804e-05\n", + "Epoch 48/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1198e-05 - val_loss: 9.9396e-05\n", + "Epoch 49/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1456e-05 - val_loss: 9.6983e-05\n", + "Epoch 50/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.0804e-05 - val_loss: 1.0056e-04\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "\n", + "# Define the model\n", + "def create_model(input_shape=(8, 8, 1), max_hits=5):\n", + " model = tf.keras.Sequential([\n", + " tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + " tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(128, activation='relu'),\n", + " tf.keras.layers.Dense(max_hits * 2) # Predict x and y for each hit, so output shape is (max_hits * 2,)\n", + " ])\n", + " return model\n", + "with strategy.scope():\n", + " # Create an instance of the model\n", + " model = create_model()\n", + "\n", + " # Compile the model\n", + " model.compile(optimizer='adam', loss='mse')\n", + "\n", + "# Train the model\n", + "history = model.fit(\n", + " train_dataset, # Dataset prepared in your previous code\n", + " validation_data=val_dataset,\n", + " epochs=50,\n", + " batch_size=1000\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# loaded_model = tf.keras.models.load_model('/home/da886/Final Electron counting project/Post Training Analysis/20KFixed_Mixed_5_32by32_Tiles_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "\n", + "# def predict_and_visualize(model, data_loader, dataset, img_idx=0, tile_size=8, max_hits_per_tile=5, threshold=0.5):\n", + "# \"\"\"\n", + "# Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " \n", + "# Parameters:\n", + "# - model: Trained Keras model for prediction.\n", + "# - data_loader: DataLoader instance to access image and tile information.\n", + "# - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + "# - img_idx: int, the index of the image in the dataset to visualize.\n", + "# - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "# - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + "# \"\"\"\n", + "# # Extract image and true centers from dataset\n", + "# images, true_centers = next(iter(dataset))\n", + "# image_tiles = images[img_idx * 16: (img_idx + 1) * 16] # Assuming 16 tiles per 32x32 image\n", + " \n", + "# # Make predictions on the tiles of the chosen image\n", + "# predictions = model.predict(image_tiles)\n", + " \n", + "# # Reshape predictions for visualization\n", + "# predicted_centers = predictions.reshape(16, max_hits_per_tile, 2) # 16 tiles, each with max_hits_per_tile hits\n", + "\n", + "# # Reconstruct the original image from tiles\n", + "# reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + "# image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 4\n", + "# ) # 4x4 grid for a 32x32 image\n", + "\n", + "# # Visualize the original image with both true and filtered predicted hit centers\n", + "# fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + "# ax_orig.imshow(reconstructed_image, cmap='gray')\n", + "# ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + "# # Overlay true and filtered predicted centers on the reconstructed image\n", + "# for tile_idx in range(16): # 16 tiles for a 4x4 grid\n", + "# row_offset = (tile_idx // 4) * tile_size\n", + "# col_offset = (tile_idx % 4) * tile_size\n", + "\n", + "# # Plot true centers in green\n", + "# true_tile_centers = true_centers[img_idx *16 + tile_idx].numpy().reshape(-1, 2)\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot filtered predicted centers in red\n", + "# predicted_tile_centers = predicted_centers[tile_idx]\n", + "# for (x, y) in predicted_tile_centers:\n", + "# # Adjust the filter to be less restrictive\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): # Less strict filter\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Add legend\n", + "# handles, labels = ax_orig.get_legend_handles_labels()\n", + "# ax_orig.legend(handles, labels, loc='upper right')\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def predict_and_visualize(model, data_loader, dataset, img_idx=0, tile_size=8, max_hits_per_tile=5, threshold=0.5):\n", + " \"\"\"\n", + " Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access image and tile information.\n", + " - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + " \"\"\"\n", + " # Calculate the grid size based on the image and tile size\n", + " grid_size = 64 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + " # Extract image and true centers from dataset\n", + " images, true_centers = next(iter(dataset))\n", + "\n", + " # Adjust the indices to select the correct tiles for the image\n", + " image_tiles = images[img_idx * grid_size**2: (img_idx + 1) * grid_size**2] # 64 tiles per image\n", + "\n", + " # Make predictions on the tiles of the chosen image\n", + " predictions = model.predict(image_tiles)\n", + "\n", + " # Reshape predictions for visualization\n", + " predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + " ) # 8x8 grid for a 64x64 image\n", + "\n", + " # Visualize the original image with both true and filtered predicted hit centers\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + " # Overlay the tile boundaries\n", + " for i in range(1, grid_size):\n", + " # Horizontal lines\n", + " ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " # Vertical lines\n", + " ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true and filtered predicted centers on the reconstructed image\n", + " for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " # Plot true centers in green\n", + " true_tile_centers = true_centers[img_idx * grid_size**2 + tile_idx].numpy().reshape(-1, 2)\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='green', marker='x', s=40,\n", + " label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot filtered predicted centers in red\n", + " predicted_tile_centers = predicted_centers[tile_idx]\n", + " for (x, y) in predicted_tile_centers:\n", + " # Adjust the filter to be less restrictive\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): # Less strict filter\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='red', marker='o', s=30,\n", + " label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 227, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApcAAAKqCAYAAABviHXiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACBY0lEQVR4nO3deZyO9f7H8feMZbLNWMKMNUs/S1OOH6lJ0kE5pXJEShJxikILLUrSZom0HUROOHVEluS059ciOcrJ0aIkIiRLxD1Zw3x/f1xnhmGY+ejimuua1/PxuB5139c9M5953bfb1z3XXHecc84JAAAA8EF80AMAAAAgOlhcAgAAwDcsLgEAAOAbFpcAAADwDYtLAAAA+IbFJQAAAHzD4hIAAAC+YXEJAAAA37C4BAAAgG9YXOK4Pfjgg4qLizuuj508ebLi4uL0ww8/+DvUIX744QfFxcVp8uTJJ+xrRJ3lfsq87WeffXbiBztB4uLi9OCDD2ZdPhmPU6vDZwxat27ddNpppwU9RiBO5vd+yy236KKLLjopXyuM3n77bZUsWVI///xz0KNALC4LpK+//lrXXXedKleurISEBFWqVEmdO3fW119/HfRogfjwww8VFxenmTNnBj1KKIwdO/aELNgz/7GSuRUvXlz169fX/fffr/T0dN+/3on00ksv6amnngp6jHwhc4Ge2xb0AjXzH6OPP/54jvszH59btmw56ufYtWuXHnzwQX344Ye+zrZ69Wr97W9/03333ZfneaNg165dGjNmjC6++GKlpKSoVKlSatiwoZ599lkdOHAg223/9Kc/qXbt2ho2bFhA0+JQhYMeACfXK6+8ok6dOqls2bLq0aOHatSooR9++EHPP/+8Zs6cqWnTpqldu3Z5+lz333+/BgwYcFxzdOnSRddcc40SEhKO6+NxcuR0P40dO1annnqqunXrdkK+5rPPPquSJUtqx44devfddzVkyBC9//77WrBgwXG/Un68jvdx+tJLL2np0qW6/fbbT8xgIXLBBRfoxRdfzHbdX/7yFzVp0kQ33XRT1nUlS5Y82aP9bhMmTFBGRkbW5V27dumhhx6SJF144YW+fZ2nn35aNWrU0B//+EffPmcYrFq1Sn379lXLli3Vr18/JSYm6p133tEtt9yiTz75RH//+9+z3b5nz56688479dBDD6lUqVIBTQ2JxWWB8v3336tLly6qWbOmPvroI5UvXz5r32233aZmzZqpS5cu+vLLL1WzZs2jfp6dO3eqRIkSKly4sAoXPr6HUKFChVSoUKHj+licPEHcTx06dNCpp54qSerVq5fat2+vV155RZ988onS0tJy/Jhdu3apePHivs/C4/T3q1mz5hHPJ7169VLNmjV13XXXHfXj9u/fr4yMDBUtWvREj3jcihQpcsK/xr59+zRlyhT16tXrhH+t/CY5OVlfffWVzjjjjKzrevbsqe7du2vSpEkaNGiQateunbWvffv26tu3r2bMmKHu3bsHMTL+ix+LFyAjR47Url279Nxzz2VbWErSqaeeqvHjx2vnzp0aMWJE1vWZPwr65ptvdO2116pMmTI6//zzs+071O7du3Xrrbfq1FNPValSpXTFFVdo/fr1eTqW7bTTTtNll12mjz/+WE2aNNEpp5yimjVr6oUXXsj2NX755RfdeeedOvPMM1WyZEklJibqkksu0RdffOFTqYPf23fffafrrrtOSUlJKl++vAYNGiTnnNatW6e2bdsqMTFRycnJGjVqVLaP/+233/TAAw+oUaNGSkpKUokSJdSsWTN98MEHR3ytrVu3qkuXLkpMTFTp0qXVtWtXffHFFzkeL/rtt9+qQ4cOKlu2rE455RQ1btxY//znP3P9fv73f/9XV155ZbbrzjzzTMXFxenLL7/Muu7ll19WXFycli1bJunI++m0007T119/rXnz5mX9OPPwV2j27t2rfv36qXz58ipRooTatWv3u46DatGihSTvR4OS94pQamqqFi9erAsuuEDFixfP+nHh3r17NXjwYNWuXVsJCQmqWrWq7r77bu3du/eIGe+44w6VL18+63H6448/HvG1j3bM5VtvvaXmzZurVKlSSkxM1Nlnn62XXnopa7433nhDa9asyfFHvn7PmJO8Pv4O/dHqc889p1q1aikhIUFnn322/v3vfx/xeV999VWlpqbqlFNOUWpqqmbPnp2neXJz6BxPPfVU1hzffPPNUe+DzMNZDv8R9Keffqo//elPSkpKUvHixdW8eXMtWLDAlzkPd+gxlz/88EPW8+pDDz2Udd9nPu9t3LhRN9xwg6pUqaKEhASlpKSobdu2uR7P+/HHH2vLli1q1apVrvNktvr444916623qnz58ipdurR69uyp3377Tdu3b9f111+vMmXKqEyZMrr77rvlnMv2OR5//HGdd955KleunIoVK6ZGjRrleMhQXp/rJWn9+vXq3r27KlasqISEBJ1xxhmaOHFirt/Pqaeemm1hmSnzp2uZz1OZKlSooLPOOktz5szJ9XPjxOKVywLktdde02mnnaZmzZrluP+CCy7QaaedpjfeeOOIfVdddZVOP/10DR069Igno0N169ZN06dPV5cuXXTuuedq3rx5atOmTZ5nXLlypTp06KAePXqoa9eumjhxorp166ZGjRplPcmsWrVKr776qq666irVqFFDmzZt0vjx49W8eXN98803qlSpUp6/Xm6uvvpq1atXT8OHD9cbb7yhRx99VGXLltX48ePVokULPfbYY5oyZYruvPNOnX322brgggskSenp6frb3/6mTp066cYbb9Svv/6q559/Xq1bt9aiRYv0hz/8QZKUkZGhyy+/XIsWLdLNN9+sunXras6cOeratesRs3z99ddq2rSpKleurAEDBqhEiRKaPn26/vznP2vWrFnHPJyhWbNmmjp1atblX375RV9//bXi4+M1f/58nXXWWZKk+fPnq3z58qpXr16On+epp55S3759VbJkSQ0cOFCSVLFixWy36du3r8qUKaPBgwfrhx9+0FNPPaU+ffro5Zdfznv4Q3z//feSpHLlymVdt3XrVl1yySW65pprdN1116lixYrKyMjQFVdcoY8//lg33XST6tWrp6+++kpPPvmkvvvuO7366qtZH/+Xv/xF//jHP3TttdfqvPPO0/vvv5/nx+nkyZPVvXt3nXHGGbr33ntVunRpLVmyRG+//bauvfZaDRw4ULFYTD/++KOefPJJSQd/5HuyZszr4y/TSy+9pF9//VU9e/ZUXFycRowYoSuvvFKrVq3KenXu3XffVfv27VW/fn0NGzZMW7duzVos+WXSpEnas2ePbrrpJiUkJKhs2bKmj3///fd1ySWXqFGjRho8eLDi4+M1adIktWjRQvPnz1eTJk1y/Ry7du3K8bjKXbt2HfPjypcvr2effVY333yz2rVrl/WPucw/W+3bt9fXX3+tvn376rTTTtPmzZs1d+5crV279pjHm/7rX/9SXFycGjZsmOvsmfr27avk5GQ99NBD+uSTT/Tcc8+pdOnS+te//qVq1app6NChevPNNzVy5Eilpqbq+uuvz/rYp59+WldccYU6d+6s3377TdOmTdNVV12l119/PdvjL6/P9Zs2bdK5556ruLg49enTR+XLl9dbb72lHj16KD09/bgOHdm4caMkZf2E41CNGjXK9ucIAXEoELZv3+4kubZt2x7zdldccYWT5NLT051zzg0ePNhJcp06dTritpn7Mi1evNhJcrfffnu223Xr1s1JcoMHD866btKkSU6SW716ddZ11atXd5LcRx99lHXd5s2bXUJCguvfv3/WdXv27HEHDhzI9jVWr17tEhIS3MMPP5ztOklu0qRJx/yeP/jgAyfJzZgx44jv7aabbsq6bv/+/a5KlSouLi7ODR8+POv6bdu2uWLFirmuXbtmu+3evXuzfZ1t27a5ihUruu7du2ddN2vWLCfJPfXUU1nXHThwwLVo0eKI2Vu2bOnOPPNMt2fPnqzrMjIy3HnnnedOP/30Y36PM2bMcJLcN99845xz7p///KdLSEhwV1xxhbv66quzbnfWWWe5du3aZV3O6X4644wzXPPmzY/4Gpm3bdWqlcvIyMi6/o477nCFChVy27dvP+aMmc2XL1/ufv75Z7d69Wo3fvx4l5CQ4CpWrOh27tzpnHOuefPmTpIbN25cto9/8cUXXXx8vJs/f36268eNG+ckuQULFjjnnPv888+dJHfLLbdku921116b6+N0+/btrlSpUu6cc85xu3fvzvbxh37Pbdq0cdWrVz/iezwRM+Ykr4+/zD8j5cqVc7/88kvW9XPmzHGS3GuvvZZ13R/+8AeXkpKS7X589913naQcv9djKVGiRLY/L5lzJCYmus2bN2e7bU6PQecO/rn94IMPnHNe/9NPP921bt06232xa9cuV6NGDXfRRRcdc6bMGXLbfv7556yP6dq1a7bv/eeff87x/tm2bZuT5EaOHJl7nMNcd911rly5cked99DPmdnq8AZpaWkuLi7O9erVK+u6zOezw/8s79q1K9vl3377zaWmproWLVpkXWd5ru/Ro4dLSUlxW7ZsyXbba665xiUlJR3x9XKzd+9eV79+fVejRg23b9++I/YPHTrUSXKbNm0yfV74ix+LFxC//vqrJOV6kHPm/sN/Ozcvx/u8/fbbkrxTZhyqb9++eZ6zfv362V5ZLV++vOrUqaNVq1ZlXZeQkKD4eO+he+DAAW3dulUlS5ZUnTp19J///CfPXysv/vKXv2T9f6FChdS4cWM559SjR4+s60uXLn3EjIUKFco6ViwjI0O//PKL9u/fr8aNG2eb8e2331aRIkV04403Zl0XHx+v3r17Z5vjl19+0fvvv6+OHTvq119/1ZYtW7RlyxZt3bpVrVu31ooVK7R+/fqjfh+ZTT/66CNJ3iuUZ599ti666CLNnz9fkrR9+3YtXbr0qK9s59VNN92U7XCJZs2a6cCBA1qzZk2ePr5OnToqX768atSooZ49e6p27dp64403sh1TmZCQoBtuuCHbx82YMUP16tVT3bp1s/ps2bIl68fqmT8SfvPNNyVJt956a7aPz8srKHPnztWvv/6qAQMG6JRTTsm2Ly+/bHQyZpTy/vjLdPXVV6tMmTJZlzMfA5mP6Q0bNujzzz9X165dlZSUlHW7iy66SPXr18/TTHnRvn37Iw7ZyavPP/9cK1as0LXXXqutW7dmtd25c6datmypjz76KNsv3xzNTTfdpLlz5x6xdenS5bjmkqRixYqpaNGi+vDDD7Vt2zbTx27dujXbfZMXPXr0yPZ4POecc4543sp8Pjv0eStz1kzbtm1TLBZTs2bNjnjeknJ/rnfOadasWbr88svlnMv2mG/durVisZj5ObtPnz765ptvNHr06ByP+c9sdazf6seJx4/FC4jMRWPmIvNojrYIrVGjRq5fY82aNYqPjz/itocecJ2batWqHXFdmTJlsj0hZ2Rk6Omnn9bYsWO1evXqbKekOPRHp344fJ6kpCSdcsopR/w4JikpSVu3bs123d///neNGjVK3377rfbt25d1/aF91qxZo5SUlCN+GeXwZitXrpRzToMGDdKgQYNynHXz5s2qXLlyjvsqVqyo008/XfPnz1fPnj01f/58/fGPf9QFF1ygvn37atWqVVq2bJkyMjJ+9+Ly8GaZT/Z5/Ut11qxZSkxMVJEiRVSlShXVqlXriNtUrlz5iF/0WLFihZYtW3bUxcnmzZslHXycHv5569Spk+tsmT+iT01NzdP3criTMWOmvDz+MuV2n2X+w+D0008/4mP9/EddXp5njmbFihWSlOMhJZlisViuC7XTTz89x+MbP/744+OeLSEhQY899pj69++vihUr6txzz9Vll12m66+/XsnJybl+vDvGoUg5yel5S5KqVq16xPWH/7l8/fXX9eijj+rzzz/PdhzwoYvVvD7X//zzz9q+fbuee+45PffccznOmvmYz4uRI0dqwoQJeuSRR3TppZfmeJvMVif7zBLIjsVlAZGUlKSUlJRsv7yRky+//FKVK1dWYmJitusP/dfsiXS038w99Ml16NChGjRokLp3765HHnlEZcuWVXx8vG6//fY8vTLxe+fJy4z/+Mc/1K1bN/35z3/WXXfdpQoVKqhQoUIaNmxY1gLFIvP7uvPOO9W6descb5PbIv7888/Xe++9p927d2vx4sV64IEHlJqaqtKlS2v+/PlatmyZSpYsaTq2Kyd56XMsF1xwQY7HUh0qp8djRkaGzjzzTD3xxBM5fszhf7EG4WTNaH38/d77zC853a9HWyQcfp7DzD8jI0eOPOKY0kxBnu7o9ttv1+WXX65XX31V77zzjgYNGqRhw4bp/fffP+afuXLlyplf7Tza/ZnT9Yfex/Pnz9cVV1yhCy64QGPHjlVKSoqKFCmiSZMmZf3CmkXmfXLdddcdddGfeUxqbiZPnqx77rlHvXr10v3333/U22W2yu05BCcWi8sC5LLLLtOECRP08ccfZ/3G96Hmz5+vH374QT179jyuz1+9enVlZGRo9erV2V7hWLly5XHPnJOZM2fqj3/8o55//vls12/fvj3fPKHMnDlTNWvW1CuvvJLtL8fBgwdnu1316tX1wQcfHHEqncObZZ7KpUiRInn6rdGcNGvWTJMmTdK0adN04MABnXfeeYqPj9f555+ftbg877zzcj31Tn59RaBWrVr64osv1LJly2POmPk4/f7777O9Erh8+fI8fQ1JWrp06TEX80f7+idjRinvj7+8ql69uqSDrw4eKq8zHa/MVxq3b9+e7frDD7PIvG8SExOP+8/I75Xbn41atWqpf//+6t+/v1asWKE//OEPGjVqlP7xj38c9WPq1q2rKVOmKBaLZTsk4USYNWuWTjnlFL3zzjvZzu06adKkbLfL63N95pkODhw48Lvukzlz5ugvf/mLrrzySo0ZM+aYt129erVOPfXU4z68Av7gmMsC5K677lKxYsXUs2fPI36E+8svv6hXr14qXry47rrrruP6/JmvqI0dOzbb9X/961+Pb+CjKFSo0BGvqMyYMeOYxxyebJkLtEPn/PTTT7Vw4cJst2vdurX27dunCRMmZF2XkZFxxBNohQoVdOGFF2r8+PHasGHDEV8vL6f6yfxx92OPPaazzjor6y+qZs2a6b333tNnn32Wpx+JlyhR4oi/6PODjh07av369dlaZtq9e7d27twpSbrkkkskSc8880y22+TlHXUuvvhilSpVSsOGDdOePXuy7Tv0vi5RooRisVggM0p5f/zlVUpKiv7whz/o73//e7bva+7cufrmm2+O63PmVeaiMfN4Ycl71fLwH7M2atRItWrV0uOPP64dO3Yc8XlOxtsCZv4D8fA/H7t27Tri8VKrVi2VKlXqiFNQHS4tLU3OOS1evNjXWXNSqFAhxcXFZXtV+Icffjjit6/z+lxfqFAhtW/fXrNmzdLSpUuP+Hp5uU8++ugjXXPNNbrgggs0ZcqUrOPtj2bx4sVHPR8uTh5euSxATj/9dP39739X586ddeaZZx7xDj1btmzR1KlTczzGLS8aNWqk9u3b66mnntLWrVuzTk/x3XffSfLvFa/LLrtMDz/8sG644Qadd955+uqrrzRlypRjnvj9ZLvsssv0yiuvqF27dmrTpo1Wr16tcePGqX79+tn+4vvzn/+sJk2aqH///lq5cqXq1q2rf/7zn/rll18kZW82ZswYnX/++TrzzDN14403qmbNmtq0aZMWLlyoH3/8MdfzfNauXVvJyclavnx5tgPvL7jgAt1zzz2SlKfFZaNGjfTss8/q0UcfVe3atVWhQoWsX0gJUpcuXTR9+nT16tVLH3zwgZo2baoDBw7o22+/1fTp0/XOO++ocePG+sMf/qBOnTpp7NixisViOu+88/Tee+/l6RX2xMREPfnkk/rLX/6is88+O+vcr1988YV27dqV9Y4hjRo10ssvv6x+/frp7LPPVsmSJXX55ZeflBmlvD/+LIYNG6Y2bdro/PPPV/fu3fXLL7/or3/9q84444zj/px5ccYZZ+jcc8/Vvffeq19++UVly5bVtGnTtH///my3i4+P19/+9jddcsklOuOMM3TDDTeocuXKWr9+vT744AMlJibqtddeO2FzSt6P9evXr6+XX35Z//M//6OyZcsqNTVV+/fvV8uWLdWxY0fVr19fhQsX1uzZs7Vp0yZdc801x/yc559/vsqVK6f/+7//O+F/ztq0aaMnnnhCf/rTn3Tttddq8+bNGjNmjGrXrp3tkCrLc/3w4cP1wQcf6JxzztGNN96o+vXr65dfftF//vMf/d///V/Wc11O1qxZoyuuuEJxcXHq0KGDZsyYkW3/WWedle3H6ps3b9aXX355xC9EIgAn/ffTEbgvv/zSderUyaWkpLgiRYq45ORk16lTJ/fVV18dcdvM08McevqNw/cdaufOna53796ubNmyrmTJku7Pf/6zW758uZOU7fQ9RzsVUZs2bY74Os2bN892uow9e/a4/v37u5SUFFesWDHXtGlTt3DhwiNu58epiA7/vrt27epKlCiR44xnnHFG1uWMjAw3dOhQV716dZeQkOAaNmzoXn/99SNOXeKcd/qSa6+91pUqVcolJSW5bt26uQULFjhJbtq0adlu+/3337vrr7/eJScnuyJFirjKlSu7yy67zM2cOfOY32Omq666yklyL7/8ctZ1v/32mytevLgrWrToEafXyel+2rhxo2vTpo0rVaqUk5TVPPO2//73v7N9jsNPGXM0x3qsHerw1of67bff3GOPPebOOOMMl5CQ4MqUKeMaNWrkHnroIReLxbJut3v3bnfrrbe6cuXKuRIlSrjLL7/crVu3Lk+nzHLOO5XTeeed54oVK+YSExNdkyZN3NSpU7P279ixw1177bWudOnSR5yqx+8Zc5LXx19Op7PJlNPXmTVrlqtXr55LSEhw9evXd6+88kqOj+ncHO1UREc7Vc/333/vWrVqlXVaqvvuu8/NnTs3x8fVkiVL3JVXXunKlSvnEhISXPXq1V3Hjh3de++9d8yZcpshp8dnTt/7v/71L9eoUSNXtGjRrIZbtmxxvXv3dnXr1nUlSpRwSUlJ7pxzznHTp08/5kyZbr31Vle7du1c5z3an0HL89nzzz/vTj/9dJeQkODq1q3rJk2a9Lue651zbtOmTa53796uatWqWX/ntGzZ0j333HPH/L4znzuOth3++Hz22Wdd8eLFs06lh+DEOXeSj9hGgfP555+rYcOG+sc//qHOnTsHPU4ovPrqq2rXrp0+/vhjNW3aNOhxAARo1apVqlu3rt566y21bNky6HGOKujn+oYNG+rCCy/MevMCBIdjLuGr3bt3H3HdU089pfj4+Kx3r0F2hzc7cOCA/vrXvyoxMVH/+7//G9BUAPKLmjVrqkePHho+fHjQo2TJb8/1b7/9tlasWKF77733pH9tHIljLuGrESNGaPHixfrjH/+owoUL66233tJbb72lm266KV+cCiY/6tu3r3bv3q20tDTt3btXr7zyiv71r39p6NChJ+0UUADyt2effTboEbLJb8/1f/rTn07osb+w4cfi8NXcuXP10EMP6ZtvvtGOHTtUrVo1denSRQMHDszx3RTgva/zqFGjtHLlSu3Zs0e1a9fWzTffrD59+gQ9GgDkiOd6HAuLSwAAAPiGYy4BAADgGxaXAAAA8E2+OzAiIyNDP/30k0qVKpVv32YOAACgIHHO6ddff1WlSpVyfaekfLe4/Omnn/itYgAAgHxo3bp1qlKlyjFvc8J+LD5mzBiddtppOuWUU3TOOedo0aJFefq4UqVKnaiRCpxRo4KeIHxoZkczO5rZ0cyOZnY0y12e1mkn4m1/pk2b5ooWLeomTpzovv76a3fjjTe60qVLu02bNuX6sbFY7Jhv98SW9y0hIfgZwrbRjGY0y58bzWhGs/yxHfo2tUdzQl65fOKJJ3TjjTfqhhtuUP369TVu3DgVL15cEydOPBFfDkcxfXrQE4QPzexoZkczO5rZ0cyOZv7wfXH522+/afHixWrVqtXBLxIfr1atWmnhwoVH3H7v3r1KT0/PtgEAACCcfF9cbtmyRQcOHFDFihWzXV+xYkVt3LjxiNsPGzZMSUlJWRu/zOOfmTODniB8aGZHMzua2dHMjmZ2NPNH4L8tfu+996pfv35Zl9PT01lg+mTt2qAnCB+a2dHMjmZ2NLOjmV3UmxUvXlynnnpqjqd6zMjI0IYNG7R///7f/XV8X1yeeuqpKlSokDZt2pTt+k2bNik5OfmI2yckJCghIcHvMSCpXz9p3rygpwgXmtnRzI5mdjSzo5ldVJvFxcXphhtu0BVXXKGiRYvmuLh0zmnLli3q37+/fv7559/19Xz/sXjRokXVqFEjvffee1nXZWRk6L333lNaWprfXw4AAADHcMMNN6hTp06qXLmyypcvr1NPPfWIrXz58qpRo4Zuvvnm3/0mNnHOOefT7Flefvllde3aVePHj1eTJk301FNPafr06fr222+POBbzcOnp6UpKSvJ7pAKpdm1p5cqgpwgXmtnRzI5mdjSzo5ldFJuVKFFCU6ZMUeXKlfN0+w0bNuj666/X9u3bc9wfi8WUmJh4zM9xQk5FdPXVV+vxxx/XAw88oD/84Q/6/PPP9fbbb+e6sIS/OnQIeoLwoZkdzexoZkczO5rZRbFZuXLlVLRo0TzfvnDhwrkuHnP9HL/ro4+hT58+6tOnz4n69MgDjkKwo5kdzexoZkczO5rZRbFZXFyc6cfc1tvn5IS9/SOCt3Vr0BOED83saGZHMzua2dHMjmb+OCHHXP4eHHMJAADgj+rVq2vcuHE69dRT83T7LVu2qFevXlqzZk2O+wM75hL5w5w5QU8QPjSzo5kdzexoZkczO5r5g8UlAAAAfMPiMsJefz3oCcKHZnY0s6OZHc3saGYXxWYZGRmyHAHpnDPdPicsLiNs6dKgJwgfmtnRzI5mdjSzo5ldFJtt2LBBW7Zs0Z49e3K97YEDBxSLxfLfO/Qg/xgwIOgJwodmdjSzo5kdzexoZhfFZvv371f//v01d+5cbdiwQT///LO2bNlyxPbzzz9r9erVGjJkiHbv3v27vuYJO88lAAAAgvfzzz/rkUceUVJSkhITE4/63uI///zz715YSpyKKNJSU6P5Ev+JRDM7mtnRzI5mdjSzo1nuOBVRAXfxxUFPED40s6OZHc3saGZHMzua+YPFZYQ1bx70BOFDMzua2dHMjmZ2NLOjmT9YXEbYjh1BTxA+NLOjmR3N7GhmRzM7mvmDYy4BAACQJxxzWcBNnx70BOFDMzua2dHMjmZ2NLOjmT9YXEZYQkLQE4QPzexoZkczO5rZ0cyOZv5gcRlhc+cGPUH40MyOZnY0s6OZHc3saOYPFpcRtmBB0BOED83saGZHMzua2dHMjmb+YHEZYQ8+GPQE4UMzO5rZ0cyOZnY0s6OZP1hcAgAAwD8un4nFYk4Smw9b48bBzxC2jWY0o1n+3GhGM5rljy0Wi+W6luOVywhr0iToCcKHZnY0s6OZHc3saGZHM3+wuIyw1q2DniB8aGZHMzua2dHMjmZ2NPMHi8sI278/6AnCh2Z2NLOjmR3N7GhmRzN/8PaPAAAAyBPe/rGAe/HFoCcIH5rZ0cyOZnY0s6OZHc38weIywnL5hwVyQDM7mtnRzI5mdjSzo5k/Cgc9AE6c+fODniB8aGZ3vM3yekROXFzc8X2BfIzHmR3N7GhmRzN/8MplhL3xRtAThA/N7H5Ps7dWvKUf138rPfKIVLWqVKiQ999HHtGP67/VWyve8m/QfITHmR3N7GhmRzOfnOiToltxEnX/tjlzgp8hbBvNTl6zN7970yUNLOS+rFLUZcTHOydlbRnx8e7LKkVd0sBCTrWD/x7zS7OCvNGMZjTLHxsnUQeQb6VWSNXgJYmqv/43xWVkZNsXl5Gh+ut/0+AlidLmgAYEAByfk/BipAmvXPq3NW0a/Axh22h28po559y+SsnZXrE8dMuQ3L5KyYF/f/mpWUHeaEYzmuWPjVcuC7g6dYKeIHxoZvd7mhXeePSXJeNy2R9mPM7saGZHMzua+YPFZYS1bRv0BOFDM7vf1axSpd+3P6R4nNnRzI5mdjTzB4tLAMG56Sa5+Jyfhlx8vHTTTSd5IADA78XbP0ZYfLx02O9JIBc0szveZs45/bj+W207t4Hqr/9N8c77UbiTlBEnfVO5qMp88oWqVqnn98iB43FmRzM7mtnRLHe8/WMBN3580BOED83sjrfZutg6NZ/VRmldftMzl5TRgUrJUny8DlRK1jOXlFFal9/UfFYbKYLvmMHjzI5mdjSzo5k/eIeeCKtQIegJwodmdsfbrFrjalInSTulfh9vU7/0/+74aaO0Q1JtadWWVVIFSelH/zxhxOPMjmZ2NLOjmT9YXEbYokVBTxA+NLM77mYrJU2Vdx7LwxeP6ZImy1tYrjzu0fItHmd2NLOjmR3N/MExlxFWs6a0alXQU4QLzexoZkczO5rZ0cyOZrnjmMsC7skng54gfGhmRzM7mtnRzI5mdjTzB4tLAAAA+IbFZYQ9/XTQE4QPzexoZkczO5rZ0cyOZv5gcRlhKSlBTxA+NLOjmR3N7GhmRzM7mvmDxWWEdewY9AThQzM7mtnRzI5mdjSzo5k/WFwCAADAN5yKKMKKFZN27w56inChmR3N7GhmRzM7mtnRLHeciqiAGzky6AnCh2Z2NLOjmR3N7GhmRzN/sLiMsKpVg54gfGhmRzM7mtnRzI5mdjTzB4vLCPvii6AnCB+a2dHMjmZ2NLOjmR3N/MExlxFWubK0fn3QU4QLzexoZkczO5rZ0cyOZrnjmMsCbuzYoCcIH5rZ0cyOZnY0s6OZHc38weISAAAAvmFxGWHjxwc9QfjQzI5mdjSzo5kdzexo5g8WlxFWvHjQE4QPzexoZkczO5rZ0cyOZv5gcRlhXboEPUH40MyOZnY0s6OZHc3saOYPFpcAAADwDaciirAyZaRt24KeIlxoZkczO5rZ0cyOZnY0yx2nIirg7r8/6AnCh2Z2NLOjmR3N7GhmRzN/sLiMsNq1g54gfGhmRzM7mtnRzI5mdjTzB4vLCFu+POgJwodmdjSzo5kdzexoZkczf3DMZYSVKydt3Rr0FOFCMzua2dHMjmZ2NLOjWe445rKAmzgx6AnCh2Z2NLOjmR3N7GhmRzN/sLgEAACAb1hcRtjkyUFPED40s6OZHc3saGZHMzua+YPFZYTt2xf0BOFDMzua2dHMjmZ2NLOjmT9YXEbYjTcGPUH40MyOZnY0s6OZHc3saOYPFpcAAADwDaciirCUFGnDhqCnCBea2dHMjmZ2NLOjmR3NcsepiAq4Pn2CniB8aGZHMzua2dHMjmZ2NPMHi8sIS00NeoLwoZkdzexoZkczO5rZ0cwf+fbH4lOnSsWLS507S0OHStWrS0uXSqNHS+PGebedMEEqUkTq1s273L27dM89Up060sqV0qOPHjytwIsvSrt2ST17epdvucX7/wYNpHXrpLvukqZN8/ZNn+69LH7bbd7lO+6QOnWSmjSRNm/2Pm72bG/fnDne20Xdfbd3ecAAqU0bqVkzKT1d6tJFmjVLKlxYeucdadEiadAg77YPPig1bSpddJG0d6/UsaM0ZYpUsqQ0b5707rvSkCHebYcP9x70l13mXW7b1jvZa7ly0sKF0syZ0qhR3r4nnpCqVfM+/9Kl3ud98kmpcmVpyRLp+ee9jpI0dqyUlOR1lrx5H3pIqllTWrbM+1wTJnj7Mk8u2727998bb5T69ZPq1ZNWrZIGD/Y6S973EYt5nSXvX4M9ekgNG0rr13tNp0/39s2cKa1d630uSerfX+rQQUpL894poXt3r7Mkvf669z0NGOBdHjhQuvhiqXlzaccO7/uYPl1KSJDmzpUWLPA6SNIjj3j3YevW0v79Uvv23ryJidL8+dIbbxz8/CNGeI+jtm29j23XTho/XqpQwbsPp071mkrS0097P0rp2NG7fM010siRUtWq0hdfeB83dqy3b/x473HdpYt3uVs36f77vfezXb5ceuyxg50nT/Z+czHzAPNevbyOqanSmjXSffd5nSVvnq1bD/6r+9Zbpeuvlxo39h7Lffp4j0PJe+x+/710553e5bvv9r7Ppk2lbdu8mWbPluLjpTff9B4zAwd6t33gAenCC6UWLaTdu73v9bvvvMfK++9LH34oPfywd9shQ7z7+9JLpYwMr+HkyVKZMt79MmeO11mSHn9cqlXLu43k3TejR3tdP/tMeuEF6ZlnvH2jR3uP+06dvMthfI547jnpl1+Cf47o0MG7HIbniD//2WskBfscMXy4d9swPEcUKSJVquTtC/I5Yto0qVixcDxHbNokbd8e/HNEfllHHPocMXSo92cvLz8Wz7eLS/x+JUt6T6bIO5rZ0cyOZnY0s6OZHc1yxzGXBVzmq1rIO5rZ0cyOZnY0s6OZHc38weISAAAAvmFxGWFTpwY9QfjQzI5mdjSzo5kdzexo5g8WlxG2dWvQE4QPzexoZkczO5rZ0cyOZv5gcRlhnK/LjmZ2NLOjmR3N7GhmRzN/sLgEAACAbzgVUYRVr+6d6wx5RzM7mtnRzI5mdjSzo1nuOBVRAXf99UFPED40s6OZHc3saGZHMzua+YPFZYQ1bhz0BOFDMzua2dHMjmZ2NLOjmT9YXEbYhg1BTxA+NLOjmR3N7GhmRzM7mvmDYy4jrHBh7/1xkXc0s6OZHc3saGZHMzua5Y5jLgu4WbOCniB8aGZHMzua2dHMjmZ2NPMHi0sAAAD4xry4/Oijj3T55ZerUqVKiouL06uvvpptv3NODzzwgFJSUlSsWDG1atVKK1as8GteGMyeHfQE4UMzO5rZ0cyOZnY0s6OZP8yLy507d6pBgwYaM2ZMjvtHjBihZ555RuPGjdOnn36qEiVKqHXr1tqzZ8/vHhY2338f9AThQzM7mtnRzI5mdjSzo5lP3O8gyc2ePTvrckZGhktOTnYjR47Mum779u0uISHBTZ06NU+fMxaLOUlsPmxz5gQ/Q9g2mtGMZvlzoxnNaJY/tlgslutaztdjLlevXq2NGzeqVatWWdclJSXpnHPO0cKFC3P8mL179yo9PT3bBgAAgHDydXG5ceNGSVLFihWzXV+xYsWsfYcbNmyYkpKSsraqVav6OVKBdvfdQU8QPjSzo5kdzexoZkczO5r5I/DfFr/33nsVi8WytnXr1gU9UmS0bRv0BOFDMzua2dHMjmZ2NLOjmT98XVwmJydLkjZt2pTt+k2bNmXtO1xCQoISExOzbfBH06ZBTxA+NLOjmR3N7GhmRzM7mvnD18VljRo1lJycrPfeey/ruvT0dH366adKS0vz80shD7ZtC3qC8KGZHc3saGZHMzua2dHMJ9bfEP/111/dkiVL3JIlS5wk98QTT7glS5a4NWvWOOecGz58uCtdurSbM2eO+/LLL13btm1djRo13O7du/ltcTY2NjY2Nja2EG95+W1x8+Lygw8+yPGLde3a1TnnnY5o0KBBrmLFii4hIcG1bNnSLV++PM+fn8Wlf9vs2cHPELaNZjSjWf7caEYzmuWPLS+Ly8IyuvDCC+WcO+r+uLg4Pfzww3r44Yetnxo+iw/817XCh2Z2NLOjmR3N7GhmRzN/kDHC3nwz6AnCh2Z2NLOjmR3N7GhmRzN/sLiMsCVLgp4gfGhmRzM7mtnRzI5mdjTzB4vLCBs4MOgJwodmdjSzo5kdzexoZkczf7C4BAAAgG/i3LF+OycA6enpSkpKCnqMSGjQQPrii6CnCBea2dHMjmZ2NLOjmR3NcheLxXJ9wxteuYywCy8MeoLwoZkdzexoZkczO5rZ0cwfLC4jrEWLoCcIH5rZ0cyOZnY0s6OZHc38weIywnbvDnqC8KGZHc3saGZHMzua2dHMHxxzCQAAgDzhmMsCbtq0oCcIH5rZ0cyOZnY0s6OZHc38weIywooVC3qC8KGZHc3saGZHMzua2dHMHywuI+z994OeIHxoZkczO5rZ0cyOZnY08weLywj78MOgJwgfmtnRzI5mdjSzo5kdzfzB4jLCHn446AnCh2Z2NLOjmR3N7GhmRzN/sLgEAACAf1w+E4vFnCQ2H7YmTYKfIWwbzWhGs/y50YxmNMsfWywWy3UtxyuXEdawYdAThA/N7GhmRzM7mtnRzI5m/mBxGWGXXhr0BOFDMzua2dHMjmZ2NLOjmT9YXEZYRkbQE4QPzexoZkczO5rZ0cyOZv7g7R8BAACQJ7z9YwE3eXLQE4QPzexoZkczO5rZ0cyOZv5gcRlhZcoEPUH40MyOZnY0s6OZHc3saOYPFpcRtmBB0BOED83saGZHMzua2dHMjmb+YHEZYXPmBD1B+NDMjmZ2NLOjmR3N7GjmDxaXETZiRNAThA/N7GhmRzM7mtnRzI5m/mBxCQAAAN+wuIywxx8PeoLwoZkdzexoZkczO5rZ0cwfLC4jrFatoCcIH5rZ0cyOZnY0s6OZHc38weIywtq1C3qC8KGZHc3saGZHMzua2dHMHywuAQAA4Bve/jHCCheW9u8PeopwoZkdzexoZkczO5rZ0Sx3vP1jATd6dNAThA/N7GhmRzM7mtnRzI5m/mBxGWEpKUFPED40s6OZHc3saGZHMzua+YPFZYR99lnQE4QPzexoZkczO5rZ0cyOZv7gmMsIq15dWrMm6CnChWZ2NLOjmR3N7GhmR7PcccxlAffMM0FPED40s6OZHc3saGZHMzua+YPFJQAAAHzD4jLC+K03O5rZ0cyOZnY0s6OZHc38weIywsqVC3qC8KGZHc3saGZHMzua2dHMHywuI6xTp6AnCB+a2dHMjmZ2NLOjmR3N/MHiEgAAAL7hVEQRVrKktGNH0FOEC83saGZHMzua2dHMjma541REBdzQoUFPED40s6OZHc3saGZHMzua+YPFZYRVrx70BOFDMzua2dHMjmZ2NLOjmT9YXEbY0qVBTxA+NLOjmR3N7GhmRzM7mvmDYy4jLCVF2rAh6CnChWZ2NLOjmR3N7GhmR7PcccxlATduXNAThA/N7GhmRzM7mtnRzI5m/mBxCQAAAN+wuIywCROCniB8aGZHMzua2dHMjmZ2NPMHi8sIK1Ik6AnCh2Z2NLOjmR3N7GhmRzN/sLiMsG7dgp4gfGhmRzM7mtnRzI5mdjTzR779bfGpU6XixaXOnb2Tmlav7p0iYPTogwfcTpjg/Ssj88HQvbt0zz1SnTrSypXSo49Kkyd7+158Udq1S+rZ07t8yy3e/zdoIK1bJ911lzRtmrdv+nTvt8Vuu827fMcd3vuNNmkibd7sfdzs2d6+OXOk5culu+/2Lg8YILVpIzVrJqWnS126SLNmSYULS++8Iy1aJA0a5N32wQelpk2liy6S9u6VOnaUpkzx3iFg3jzp3XelIUO82w4fLqWmSpdd5l1u21aaOFEqV05auFCaOVMaNcrb98QTUrVq0ogR3tfr2FF68kmpcmVpyRLp+ee9jpI0dqyUlOR1lrx5H3pIqllTWrbM+1yZPyaYOPFgZ0m68UapXz+pXj1p1Spp8GCvs+R9H7GY11mS+vSRevSQGjaU1q/3mk6f7u2bOVNau9b7XJLUv7/UoYOUliZt3ep9vTlzvH2vv+49DgYM8C4PHChdfLHUvLn3rgqdO3ufNyFBmjtXWrDA6yxJjzzi3YetW0v790vt23vzJiZK8+dLb7whvf++12zECO9x1Lat97Ht2knjx0sVKnj7p071mkrS0097v2HYsaN3+ZprpJEjpapVpS++8D5u7Fhv3/jx3uO6Sxfvcrdu0v33S7Vre4+jxx472HnyZGnfPq+zJPXq5XVMTZXWrJHuu8/rLHnzbN3q7ZekW2+Vrr9eatzYeyz36eM9DiXvsfv999Kdd3qX777b+z6bNpW2bfNmmj1bio+X3nzTe8wMHOjd9oEHpAsvlFq0kHbv9r7XH3+UFi/22n34ofTww95thwzx7u9LL5UyMryGkydLZcp498ucOV5nSXr8calWLe82knffjB7tdf3sM+mFF6RnnvH2jR7tPe4z3wM4jM8RM2Z490HQzxEdOniXw/Ac0bOn9xiXgn2OGD7cu20YniNq1fK+DynY54hp06RixcLxHFG0qPTVV8E/R+SXdcShzxFDh3p/9vLy2+L5dnGJ369cuYNPxsgbmtnRzI5mdjSzo5kdzXLHqYgKuHvuCXqC8KGZHc3saGZHMzua2dHMHywuI6xOnaAnCB+a2dHMjmZ2NLOjmR3N/MHiMsJWrgx6gvChmR3N7GhmRzM7mtnRzB8ccxlhZcp4B18j72hmRzM7mtnRzI5mdjTLHcdcFnCZv+GGvKOZHc3saGZHMzua2dHMHywuAQAA4BsWlxGWeT455B3N7GhmRzM7mtnRzI5m/mBxGWG7dgU9QfjQzI5mdjSzo5kdzexo5g8WlxGW+S4CyDua2dHMjmZ2NLOjmR3N/MHiEgAAAL7hVEQRVrmy9x69yDua2dHMjmZ2NLOjmR3NcsepiAo4Xt63o5kdzexoZkczO5rZ0cwfLC4jrEGDoCcIH5rZ0cyOZnY0s6OZHc38weIywtatC3qC8KGZHc3saGZHMzua2dHMHxxzGWHFikm7dwc9RbjQzI5mdjSzo5kdzexoljuOuSzgpk0LeoLwoZkdzexoZkczO5rZ0cwfLC4BAADgGxaXETZ9etAThA/N7GhmRzM7mtnRzI5m/mBxGWEbNgQ9QfjQzI5mdjSzo5kdzexo5g8WlxF2221BTxA+NLOjmR3N7GhmRzM7mvmDxSUAAAB8w6mIIqxmTWnVqqCnCBea2dHMjmZ2NLOjmR3NcsepiAq4Tp2CniB8aGZHMzua2dHMjmZ2NPMHi8sIa9Ik6AnCh2Z2NLOjmR3N7GhmRzN/sLiMsM2bg54gfGhmRzM7mtnRzI5mdjTzB8dcRlh8vJSREfQU4UIzO5rZ0cyOZnY0s6NZ7jjmsoCbPTvoCcKHZnY0s6OZHc3saGZHM3+wuAQAAIBvWFxG2Jw5QU8QPjSzo5kdzexoZkczO5r5g8VlhC1fHvQE4UMzO5rZ0cyOZnY0s6OZP1hcRtjddwc9QfjQzI5mdjSzo5kdzexo5g8WlwAAAPCPMxg6dKhr3LixK1mypCtfvrxr27at+/bbb7PdZvfu3e6WW25xZcuWdSVKlHBXXnml27hxY56/RiwWc5LYfNjq1Qt+hrBtNKMZzfLnRjOa0Sx/bLFYLNe1nOmVy3nz5ql379765JNPNHfuXO3bt08XX3yxdu7cmXWbO+64Q6+99ppmzJihefPm6aefftKVV15p+TLwSZs2QU8QPjSzo5kdzexoZkczO5r5xPLK5eE2b97sJLl58+Y555zbvn27K1KkiJsxY0bWbZYtW+YkuYULF+bpc/LKpX/bnDnBzxC2jWY0o1n+3GhGM5rlj833Vy4PF4vFJElly5aVJC1evFj79u1Tq1atsm5Tt25dVatWTQsXLvw9XwrHIT096AnCh2Z2NLOjmR3N7GhmRzN/HPfbP2ZkZOiKK67Q9u3b9fHHH0uSXnrpJd1www3au3dvtts2adJEf/zjH/XYY48d8Xn27t2b7fbp6emqWrXq8YwEAACAE+iEvv1j7969tXTpUk2bNu14P4UkadiwYUpKSsraWFj6Z9asoCcIH5rZ0cyOZnY0s6OZHc38cVyLyz59+uj111/XBx98oCpVqmRdn5ycrN9++03bt2/PdvtNmzYpOTk5x8917733KhaLZW3r1q07npGQg8KFg54gfGhmRzM7mtnRzI5mdjTzh2lx6ZxTnz59NHv2bL3//vuqUaNGtv2NGjVSkSJF9N5772Vdt3z5cq1du1ZpaWk5fs6EhAQlJiZm2+CPd94JeoLwoZkdzexoZkczO5rZ0cwfpjV679699dJLL2nOnDkqVaqUNm7cKElKSkpSsWLFlJSUpB49eqhfv34qW7asEhMT1bdvX6Wlpencc889Id8Ajm7RoqAnCB+a2dHMjmZ2NLOjmR3NfGI59ZCO8mvpkyZNyrpN5knUy5Qp44oXL+7atWvnNmzYkOevwamI/Ns4pQLNaJY/N5rRjGb5c6NZ7lteTkVkeuUyL79Yfsopp2jMmDEaM2aM5VMDAAAgAo77VEQnSnp6upKSkoIeIxIaNpSWLAl6inChmR3N7GhmRzM7mtnRLHcn9FREyP+aNg16gvChmR3N7GhmRzM7mtnRzB8sLiPsoouCniB8aGZHMzua2dHMjmZ2NPMHi8sIO+yNkpAHNLOjmR3N7GhmRzM7mvmDYy4BAACQJxxzWcBNmRL0BOFDMzua2dHMjmZ2NLOjmT9YXEZYyZJBTxA+NLOjmR3N7GhmRzM7mvmDxWWEzZsX9AThQzM7mtnRzI5mdjSzo5k/WFxG2LvvBj1B+NDMjmZ2NLOjmR3N7GjmDxaXETZkSNAThA/N7GhmRzM7mtnRzI5m/mBxCQAAAN+wuIyw4cODniB8aGZHMzua2dHMjmZ2NPMHi8sIS00NeoLwoZkdzexoZkczO5rZ0cwfLC4j7LLLgp4gfGhmRzM7mtnRzI5mdjTzB4tLAAAA+Ia3fwQAAECe8PaPBdzEiUFPED40s6OZHc3saGZHMzua+YPFZYSVKxf0BOFDMzua2dHMjmZ2NLOjmT9YXEbYwoVBTxA+NLOjmR3N7GhmRzM7mvmDxWWEzZwZ9AThQzM7mtnRzI5mdjSzo5k/WFxG2KhRQU8QPjSzo5kdzexoZkczO5r5g8UlAAAAfMPiMsKeeCLoCcKHZnY0s6OZHc3saGZHM3+wuIywatWCniB8aGZHMzua2dHMjmZ2NPMHi8sI69Ah6AnCh2Z2NLOjmR3N7GhmRzN/sLgEAACAb3j7xwhLSJD27g16inChmR3N7GhmRzM7mtnRLHe8/WMB9+STQU8QPjSzo5kdzexoZkczuyg2c87pze/e1Nrta+WcO2Jbu32tVNvfr8niMsIqVw56gvChmR3N7GhmRzM7mtlFsdlbK97SFdOu0IV/v1A/rv9WeuQRqWpVqVAh7a+copnXNlCJ9vJ1gVnYv0+F/GbJkqAnCB+a2dHMjmZ2NLOjmV0Um6VWSFW1pGratHGVtp3bQJV/2q+4jAxJUuGfNurWDVKzf0sX7pF2+vVFXT4Ti8WcJDYftqpVg58hbBvNaEaz/LnRjGY0O77NOefWbl/rnri0jNsfJ+d05LZfcvfn8fPFYrFc13L8WDzCRo8OeoLwoZkdzexoZkczO5rZRbVZ1aSq6vt5ggq5nPfHS7rJx6+Xb38sPnWqVLy41LmzNHSoVL26tHSpd8ePG+fdZsIEqUgRqVs373L37tI990h16kgrV0qPPipNnuzte/FFadcuqWdP7/Itt3j/36CBtG6ddNdd0rRp3r7p06UNG6TbbvMu33GH1KmT1KSJtHmz93GzZ3v75syRli+X7r7buzxggNSmjdSsmZSeLnXpIs2aJRUuLL3zjrRokTRokHfbBx+UmjaVLrrI++20jh2lKVOkkiWlefOkd9+Vhgzxbjt8uJSaKl12mXe5bVtp4kSpXDlp4UJp5syD74n6xBPeiWCbNPHm69jRO0i5cmXvJf/nnz/4B2jsWCkpyessefM+9JBUs6a0bJn3uSZM8PZNnHiwsyTdeKPUr59Ur560apU0eLDXWfK+j1jM6yxJffpIPXpIDRtK69d7TadP9/bNnCmtXet9Lknq398711hamrR1q/f15szx9r3+uvc4GDDAuzxwoHTxxVLz5tKOHd73MX269xt/c+dKCxZ4nSXvMJMmTaTWraX9+6X27b15ExOl+fOlN9442GzECO9x1Lat97Ht2knjx0sVKnj34dSpBw/8fvppKSXF6yxJ11wjjRzpHdLyxRfex40d6+0bP957XHfp4l3u1k26/36pdm3vcfTYYwc7T54s7dvndZakXr28jqmp0po10n33eZ0lb56tW739knTrrdL110uNG3uP5T59vMeh5D12v/9euvNO7/Ldd3vfZ9Om0rZt3kyzZ0vx8dKbb3qPmYEDvds+8IB04YVSixbS7t3e99qokdfs/felDz+UHn7Yu+2QId79femlUkaG13DyZKlMGe9+yewsSY8/LtWq5d1G8u6b0aO9rp99Jr3wgvTMM96+0aO9x32nTt7lMD5H1KrlXR/0c0TmOf3C8BxRrtzB54EgnyOGD/duG4bniMKFD3YJ8jli2jSpWLFwPEcULXrwvo3KOkK6QpJUuMYmqY2k/z5HqK2kiZLKSXELpUozpTnHeI4YOtT7s5cnJ/rH3Fb8WNy/rXXr4GcI20YzmtEsf240oxnNjm/LtK9Sco4/EneSy5Dc2jx+Pn4sXsBxulA7mtnRzI5mdjSzo5ldVJuti63TX/+wVwfict6fIek5H78ei8sIy/wxFvKOZnY0s6OZHc3saGYXxWbrYut04d8v1KAG2/RN5aJy8QeXfk7SgThpSXnpyVL+fU0WlwAAABG1dPNSrY2tVcXkmirzyReKe/BBqUoVKT5eByol65lLyujC7tLOiv59Td7+McISE72DgZF3NLOjmR3N7GhmRzO7yDarLWmzpJy+t0RJFSStzNun4u0fC7iHHgp6gvChmR3N7GhmRzM7mtlFttlK5byw1H+vz+PCMq9YXEZYzZpBTxA+NLOjmR3N7GhmRzM7mvmDxWWELVsW9AThQzM7mtnRzI5mdjSzo5k/OOYywipU8E7WiryjmR3N7GhmRzM7mtnRLHccc1nAZb5rBvKOZnY0s6OZHc3saGZHM3+wuAQAAIBvWFxGWOb7zyLvaGZHMzua2dHMjmZ2NPMHi0sAAAD4hsVlhHXvHvQE4UMzO5rZ0cyOZnY0s6OZP1hcAgAAwDeciijCOKWCHc3saGZHMzua2dHMjma541REBVy/fkFPED40s6OZHc3saGZHMzua+YPFZYTVqxf0BOFDMzua2dHMjmZ2NLOjmT9YXEbYqlVBTxA+NLOjmR3N7GhmRzM7mvmDYy4jLDFRSk8PeopwoZkdzexoZkczO5rZ0Sx3HHNZwL34YtAThA/N7GhmRzM7mtnRzI5m/mBxCQAAAN+wuIywKVOCniB8aGZHMzua2dHMjmZ2NPMHi8sIi8WCniB8aGZHMzua2dHMjmZ2NPMHi8sIu+WWoCcIH5rZ0cyOZnY0s6OZHc38weISAAAAvuFURBFWtaq0bl3QU4QLzexoZkczO5rZ0cyOZrnjVEQFXI8eQU8QPjSzo5kdzexoZkczO5r5g8VlhDVsGPQE4UMzO5rZ0cyOZnY0s6OZP1hcRtj69UFPED40s6OZHc3saGZHMzua+YNjLiMsIUHauzfoKcKFZnY0s6OZHc3saGZHs9xxzGUBN3160BOED83saGZHMzua2dHMjmb+YHEJAAAA37C4jLCZM4OeIHxoZkczO5rZ0cyOZnY08weLywhbuzboCcKHZnY0s6OZHc3saGZHM3+wuIywfv2CniB8aGZHMzua2dHMjmZ2NPMHi0sAAAD4hlMRRVjt2tLKlUFPES40s6OZHc3saGZHMzua5Y5TERVwHToEPUH40MyOZnY0s6OZHc3saOYPFpcRlpYW9AThQzM7mtnRzI5mdjSzo5k/WFxG2NatQU8QPjSzo5kdzexoZkczO5r5g2MuAQAAkCccc1nAzZkT9AThQzM7mtnRzI5mdjSzo5k/WFwCAADANywuI+z114OeIHxoZkczO5rZ0cyOZnY08weLywhbujToCcKHZnY0s6OZHc3saGZHM3+wuIywAQOCniB8aGZHMzua2dHMjmZ2NPMHi0sAAAD4hlMRRVhqKi/xW9HMjmZ2NLOjmR3N7GiWO05FVMBdfHHQE4QPzexoZkczO5rZ0cyOZv5gcRlhzZsHPUH40MyOZnY0s6OZHc3saOYPFpcRtmNH0BOED83saGZHMzua2dHMjmY+cQZjx451Z555pitVqpQrVaqUO/fcc92bb76ZtX/37t3ulltucWXLlnUlSpRwV155pdu4caPlS7hYLOYksbGxsbGxsbGx5bMtFovlupYzvXJZpUoVDR8+XIsXL9Znn32mFi1aqG3btvr6668lSXfccYdee+01zZgxQ/PmzdNPP/2kK6+80vIl4KPp04OeIHxoZkczO5rZ0cyOZnY080dhy40vv/zybJeHDBmiZ599Vp988omqVKmi559/Xi+99JJatGghSZo0aZLq1aunTz75ROeee65/UyNPEhKCniB8aGZHMzua2dHMjmZ2NPPHcR9zeeDAAU2bNk07d+5UWlqaFi9erH379qlVq1ZZt6lbt66qVaumhQsX+jIsbObODXqC8KGZHc3saGZHMzua2dHMH6ZXLiXpq6++Ulpamvbs2aOSJUtq9uzZql+/vj7//HMVLVpUpUuXznb7ihUrauPGjUf9fHv37tXevXuzLqenp1tHwlEsWBD0BOFDMzua2dHMjmZ2NLOjmT/Mr1zWqVNHn3/+uT799FPdfPPN6tq1q7755pvjHmDYsGFKSkrK2qpWrXrcnwvZPfhg0BOED83saGZHMzua2dHMjmb+MC8uixYtqtq1a6tRo0YaNmyYGjRooKefflrJycn67bfftH379my337Rpk5KTk4/6+e69917FYrGsbd26deZvAgAAAPmE6TxBOfjjH//ounbt6rZv3+6KFCniZs6cmbXv22+/dZLcwoUL8/z5OBWRf1vjxsHPELaNZjSjWf7caEYzmuWPzfdTEd1777366KOP9MMPP+irr77Svffeqw8//FCdO3dWUlKSevTooX79+umDDz7Q4sWLdcMNNygtLY3fFA9IkyZBTxA+NLOjmR3N7GhmRzM7mvnDtLjcvHmzrr/+etWpU0ctW7bUv//9b73zzju66KKLJElPPvmkLrvsMrVv314XXHCBkpOT9corr5yQwZG71q2DniB8aGZHMzua2dHMjmZ2NPOH6bfFn3/++WPuP+WUUzRmzBiNGTPmdw0Ff+zfH/QE4UMzO5rZ0cyOZnY0s6OZP+Kccy7oIQ6Vnp6upKSkoMcAAADAYWKxmBITE495m+M+iTryvxdfDHqC8KGZHc3saGZHMzua2dHMHywuIyyXf1ggBzSzo5kdzexoZkczO5r5g8VlhM2fH/QE4UMzO5rZ0cyOZnY0s6OZP1hcRtgbbwQ9QfjQzI5mdjSzo5kdzexo5g8WlxE2fHjQE4QPzexoZkczO5rZ0cyOZv5gcQkAAADfsLiMsBEjgp4gfGhmRzM7mtnRzI5mdjTzB4vLCKtTJ+gJwodmdjSzo5kdzexoZkczf7C4jLC2bYOeIHxoZkczO5rZ0cyOZnY08weLSwAAAPiGt3+MsPh4KSMj6CnChWZ2NLOjmR3N7GhmR7Pc8faPBdz48UFPED40s6OZHc3saGZHMzua+SPfvnI5dapUvLjUubM0dKhUvbq0dKk0erQ0bpx32wkTpCJFpG7dvMvdu0v33OMdkLtypfToo9Lkyd6+F1+Udu2Sevb0Lt9yi/f/DRpI69ZJd90lTZvm7Zs+XdqwQbrtNu/yHXdInTpJTZpImzd7Hzd7trdvzhxp+XLp7ru9ywMGSG3aSM2aSenpUpcu0qxZUuHC0jvvSIsWSYMGebd98EGpaVPpooukvXuljh2lKVOkkiWlefOkd9+Vhgzxbjt8uJSaKl12mXe5bVtp4kSpXDlp4UJp5kxp1Chv3xNPSNWqeb/1tmiR93mffFKqXFlaskR6/nmvoySNHSslJXmdJW/ehx6SataUli3zPteECd6+iRMPdpakG2+U+vWT6tWTVq2SBg8++L6sU6ZIsZjXWZL69JF69JAaNpTWr/eaTp/u7Zs5U1q71vtcktS/v9Shg5SWJm3d6n29OXO8fa+/7j0OBgzwLg8cKF18sdS8ubRjh/d9TJ8uJSRIc+dKCxZ4nSXpkUe8+7B1a2n/fql9e2/exETvXRneeEN6/32v2YgR3uMo8/ibdu28J50KFbz9U6d6TSXp6aellBSvsyRdc400cqRUtar0xRfex40d6+0bP957XHfp4l3u1k26/36pdm3vcfTYYwc7T54s7dvndZakXr28jqmp0po10n33eZ0lb56tW739knTrrdL110uNG3uP5T59vMeh5D12v/9euvNO7/Ldd3vfZ9Om0rZt3kyzZ3v/gn/zTe8xM3Cgd9sHHpAuvFBq0ULavdv7Xn/8UVq82Gv34YfSww97tx0yxLu/L73UeyWgXTvveypTxrtf5sw5+JuZjz8u1arl3Uby7pvRo72un30mvfCC9Mwz3r7Ro73HfadO3uUwPkfMmOHdB0E/R3To4F0Ow3NEz57eY1wK9jki8zyIYXiOqFXL+z6kYJ8jpk2TihULx3NE0aLSV18F/xyRX9YRhz5HDB3q/dnLyyuXcvlMLBZzkth82AYODH6GsG00oxnN8udGM5rRLH9ssVgs17Vcvn3lEr9fzZreqwXIO5rZ0cyOZnY0s6OZHc1yxzGXBVzmj2SQdzSzo5kdzexoZkczO5r5g8UlAAAAfMPiMsKefjroCcKHZnY0s6OZHc3saGZHM3+wuIywlJSgJwgfmtnRzI5mdjSzo5kdzfzB4jLCMk97gbyjmR3N7GhmRzM7mtnRzB8sLgEAAOAbTkUUYcWKeSexRd7RzI5mdjSzo5kdzexoljtORVTAjRwZ9AThQzM7mtnRzI5mdjSzo5k/WFxGWNWqQU8QPjSzo5kdzexoZkczO5r5g8VlhH3xRdAThA/N7GhmRzM7mtnRzI5m/uCYywirXFlavz7oKcKFZnY0s6OZHc3saGZHs9xxzGUBN3Zs0BOED83saGZHMzua2dHMjmb+YHEJAAAA37C4jLDx44OeIHxoZkczO5rZ0cyOZnY08weLywgrXjzoCcKHZnY0s6OZHc3saGZHM3+wuIywLl2CniB8aGZHMzua2dHMjmZ2NPMHi0sAAAD4hlMRRViZMtK2bUFPES40s6OZHc3saGZHMzua5Y5TERVw998f9AThQzM7mtnRzI5mdjSzo5k/WFxGWO3aQU8QPjSzo5kdzexoZkczO5r5g8VlhC1fHvQE4UMzO5rZ0cyOZnY0s6OZPzjmMsLKlZO2bg16inChmR3N7GhmRzM7mtnRLHccc1nATZwY9AThQzM7mtnRzI5mdjSzo5k/WFwCAADANywuI2zy5KAnCB+a2dHMjmZ2NLOjmR3N/MHiMsL27Qt6gvChmR3N7GhmRzM7mtnRzB8sLiPsxhuDniB8aGZHMzua2dHMjmZ2NPMHi0sAAAD4hlMRRVhKirRhQ9BThAvN7GhmRzM7mtnRzI5mueNURAVcnz5BTxA+NLOjmR3N7GhmRzM7mvmDxWWEpaYGPUH40MyOZnY0s6OZHc3saOYPFpcRtmZN0BOED83saGZHMzua2dHMjmb+4JjLCCtZUtqxI+gpwoVmdjSzo5kdzexoZkez3HHMZQE3ZUrQE4QPzexoZkczO5rZ0cyOZv5gcQkAAADfsLiMsKlTg54gfGhmRzM7mtnRzI5mdjTzB4vLCNu6NegJwodmdjSzo5kdzexoZkczf7C4jDDO12VHMzua2dHMjmZ2NLOjmT9YXAIAAMA3nIoowqpX55xdVjSzo5kdzexoZkczO5rljlMRFXDXXx/0BOFDMzua2dHMjmZ2NLOjmT9YXEZY48ZBTxA+NLOjmR3N7GhmRzM7mvmDxWWEbdgQ9AThQzM7mtnRzI5mdjSzo5k/OOYywgoXlvbvD3qKcKGZHc3saGZHMzua2dEsdxxzWcDNmhX0BOFDMzua2dHMjmZ2NLOjmT9YXAIAAMA3LC4jbPbsoCcIH5rZ0cyOZnY0s6OZHc38weIywr7/PugJwodmdjSzo5kdzexoZkczf7C4jLA77wx6gvChmR3N7GhmRzM7mtnRzB8sLgEAAOAbTkUUYXXqSMuXBz1FuNDMjmZ2NLOjmR3N7GiWO05FVMC1bRv0BOFDMzua2dHMjmZ2NLOjmT9YXEZY06ZBTxA+NLOjmR3N7GhmRzM7mvmDxWWEbdsW9AThQzM7mtnRzI5mdjSzo5k/OOYSAAAAecIxlwUcJ4O1o5kdzexoZkczO5rZ0cwfLC4jLJ5714xmdjSzo5kdzexoZkczf5Axwt58M+gJwodmdjSzo5kdzexoZkczf7C4jLAlS4KeIHxoZkczO5rZ0cyOZnY08weLywgbODDoCcKHZnY0s6OZHc3saGZHM3+wuAQAAIBvOBVRhDVoIH3xRdBThAvN7GhmRzM7mtnRzI5mueNURAXchRcGPUH40MyOZnY0s6OZHc3saOYPFpcR1qJF0BOED83saGZHMzua2dHMjmb+YHEZYbt3Bz1B+NDMjmZ2NLOjmR3N7GjmD465BAAAQJ5wzGUBN21a0BOED83saGZHMzua2dHMjmb+YHEZYcWKBT1B+NDMjmZ2NLOjmR3N7GjmDxaXEfb++0FPED40s6OZHc3saGZHMzua+YPFZYR9+GHQE4QPzexoZkczO5rZ0cyOZv74XYvL4cOHKy4uTrfffnvWdXv27FHv3r1Vrlw5lSxZUu3bt9emTZt+75w4Dg8/HPQE4UMzO5rZ0cyOZnY0s6OZP457cfnvf/9b48eP11lnnZXt+jvuuEOvvfaaZsyYoXnz5umnn37SlVde+bsHBQAAQAi44/Drr7+6008/3c2dO9c1b97c3Xbbbc4557Zv3+6KFCniZsyYkXXbZcuWOUlu4cKFefrcsVjMSWLzYWvSJPgZwrbRjGY0y58bzWhGs/yxxWKxXNdyx/XKZe/evdWmTRu1atUq2/WLFy/Wvn37sl1ft25dVatWTQsXLszxc+3du1fp6enZNvijYcOgJwgfmtnRzI5mdjSzo5kdzfxR2PoB06ZN03/+8x/9+9//PmLfxo0bVbRoUZUuXTrb9RUrVtTGjRtz/HzDhg3TQw89dMT1U6dKxYtLnTtLQ4dK1atLS5dKo0dL48Z5t5kwQSpSROrWzbvcvbt0zz1SnTrSypXSo49Kkyd7+158Udq1S+rZ07t8yy3e/zdoIK1bJ91118HzW02fLm3YIN12m3f5jjukTp2kJk2kzZu9j5s929s3Z460fLl0993e5QEDpDZtpGbNpPR0qUsXadYsqXBh6Z13pEWLpEGDvNs++KDUtKl00UXS3r1Sx47SlClSyZLSvHnSu+9KQ4Z4tx0+XEpNlS67zLvctq00caJUrpy0cKE0c6Y0apS374knpGrVvM9/6aXe533ySalyZWnJEun5572OkjR2rJSU5HWWvHkfekiqWVNatsz7XBMmePsmTjzYWZJuvFHq10+qV09atUoaPNjrLHnfRyzmdZakPn2kHj28P7jr13tNp0/39s2cKa1d630uSerfX+rQQUpLk7Zu9b7enDnevtdf9x4HAwZ4lwcOlC6+WGreXNqxw/s+pk+XEhKkuXOlBQu8DpL0yCPefdi6tbR/v9S+vTdvYqI0f770xhsHm40Y4T2O2rb1PrZdO2n8eKlCBe8+nDrVaypJTz8tpaR4nSXpmmukkSOlqlWlL77wPm7sWG/f+PHe47pLF+9yt27S/fdLtWt7j6PHHjvYefJkad8+r7Mk9erldUxNldaske67z+ssefNs3ertl6Rbb5Wuv15q3Nh7LPfp4z0OJe+x+/330p13epfvvtv7Pps2lbZt82aaPVuKj5fefNN7zAwc6N32gQe8995t0cJ7J4trrvEez5de6v2W5YcfHjxmacgQ7/6+9FIpI8NrOHmyVKaMd7/MmeN1lqTHH5dq1fJuI3n3zejRXtfPPpNeeEF65hlv3+jR3uO+UyfvchifI/r29boE/RzRoYN3OQzPEV26eM2kYJ8jhg/3bhuG54hatQ42C/I5Yto07xQ/YXiOKFrU+zpBP0fkl3XEoc8RQ4d6f/byxPLj8LVr17oKFSq4L774Iuu6Q38sPmXKFFe0aNEjPu7ss892d999d46fc8+ePS4Wi2Vt69atC/wl36hss2cHP0PYNprRjGb5c6MZzWiWP7a8/FjctLicPXu2k+QKFSqUtUlycXFxrlChQu7//u//nCS3bdu2bB9XrVo198QTT+Tpa3DMJRsbGxsbGxtb/tx8P+ayZcuW+uqrr/T5559nbY0bN1bnzp2z/r9IkSJ67733sj5m+fLlWrt2rdLS0ixfCj7IfCkfeUczO5rZ0cyOZnY0s6OZP0zHXJYqVUqpqanZritRooTKlSuXdX2PHj3Ur18/lS1bVomJierbt6/S0tJ07rnn+jc18qRMmaAnCB+a2dHMjmZ2NLOjmR3N/GH+hZ7cPPnkk4qPj1f79u21d+9etW7dWmMzj1TGSbVgQdAThA/N7GhmRzM7mtnRzI5m/ohzzrmghzhUenq6kpKSgh4jEurU8X4DDXlHMzua2dHMjmZ2NLOjWe5isZgSExOPeRveWzzCMk/hgLyjmR3N7GhmRzM7mtnRzB8sLgEAAOAbFpcR9vjjQU8QPjSzo5kdzexoZkczO5r5g8VlhNWqFfQE4UMzO5rZ0cyOZnY0s6OZP1hcRljm22Qh72hmRzM7mtnRzI5mdjTzB4tLAAAA+IZTEUVY4cLS/v1BTxEuNLOjmR3N7GhmRzM7muWOUxEVcKNHBz1B+NDMjmZ2NLOjmR3N7GjmDxaXEZaSEvQE4UMzO5rZ0cyOZnY0s6OZP1hcRthnnwU9QfjQzI5mdjSzo5kdzexo5g+OuYyw6tWlNWuCniJcaGZHMzua2dHMjmZ2NMsdx1wWcM88E/QE4UMzO5rZ0cyOZnY0s6OZP1hcAgAAwDcsLiOM33qzo5kdzexoZkczO5rZ0cwfLC4jrFy5oCcIH5rZ0cyOZnY0s6OZHc38weIywjp1CnqC8KGZHc3saGZHMzua2dHMHywuAQAA4BtORRRhJUtKO3YEPUW40MyOZnY0s6OZHc3saJY7TkVUwA0dGvQE4UMzO5rZ0cyOZnY0s6OZP1hcRlj16kFPED40s6OZHc3saGZHMzua+YPFZYQtXRr0BOFDMzua2dHMjmZ2NLOjmT845jLCUlKkDRuCniJcaGZHMzua2dHMjmZ2NMsdx1wWcOPGBT1B+NDMjmZ2NLOjmR3N7GjmDxaXAAAA8A2LywibMCHoCcKHZnY0s6OZHc3saGZHM3+wuIywIkWCniB8aGZHMzua2dHMjmZ2NPMHi8sI69Yt6AnCh2Z2NLOjmR3N7GhmRzN/sLgEAACAbzgVUYSVKydt3Rr0FOFCMzua2dHMjmZ2NLOjWe44FVEBd889QU8QPjSzo5kdzexoZkczO5r5g8VlhNWpE/QE4UMzO5rZ0cyOZnY0s6OZP1hcRtjKlUFPED40s6OZHc3saGZHMzua+YNjLiOsTBlp27agpwgXmtnRzI5mdjSzo5kdzXLHMZcF3OTJQU8QPjSzo5kdzexoZkczO5r5g8UlAAAAfMPiMsJefDHoCcKHZnY0s6OZHc3saGZHM3+wuIywXbuCniB8aGZHMzua2dHMjmZ2NPMHi8sI69kz6AnCh2Z2NLOjmR3N7GhmRzN/sLgEAACAbzgVUYRVriytXx/0FOFCMzua2dHMjmZ2NLOjWe44FVEBx8v7djSzo5kdzexoZkczO5r5g8VlhDVoEPQE4UMzO5rZ0cyOZnY0s6OZP1hcRti6dUFPED40s6OZHc3saGZHMzua+YNjLiOsWDFp9+6gpwgXmtnRzI5mdjSzo5kdzXLHMZcF3LRpQU8QPjSzo5kdzexoZkczO5r5g8UlAAAAfMPiMsKmTw96gvChmR3N7GhmRzM7mtnRzB8sLiNsw4agJwgfmtnRzI5mdjSzo5kdzfzB4jLCbrst6AnCh2Z2NLOjmR3N7GhmRzN/sLgEAACAbzgVUYTVrCmtWhX0FOFCMzua2dHMjmZ2NLOjWe44FVEB16lT0BOED83saGZHMzua2dHMjmb+YHEZYU2aBD1B+NDMjmZ2NLOjmR3N7GjmDxaXEbZ5c9AThA/N7GhmRzM7mtnRzI5m/uCYywiLj5cyMoKeIlxoZkczO5rZ0cyOZnY0yx3HXBZws2cHPUH40MyOZnY0s6OZHc3saOYPFpcAAADwDYvLCJszJ+gJwodmdjSzo5kdzexoZkczf7C4jLDly4OeIHxoZkczO5rZ0cyOZnY08weLywi7++6gJwgfmtnRzI5mdjSzo5kdzfzB4hIAAAC+4VREEVavnrRsWdBThAvN7GhmRzM7mtnRzI5mueNURAVcmzZBTxA+NLOjmR3N7GhmRzM7mvmDxWWENWsW9AThQzM7mtnRzI5mdjSzo5k/WFxGWHp60BOED83saGZHMzua2dHMjmb+4JhLAAAA5AnHXBZws2YFPUH40MyOZnY0s6OZHc3saOYPFpcRVrhw0BOED83saGZHMzua2dHMjmb+YHEZYe+8E/QE4UMzO5rZ0cyOZnY0s6OZP1hcRtiiRUFPED40s6OZHc3saGZHMzua+SPfvgA8dapUvLjUubM0dKhUvbq0dKk0erQ0bpx3mwkTpCJFpG7dvMvdu0v33CPVqSOtXCk9+qg0ebK378UXpV27pJ49vcu33OL9f4MG0rp10l13SdOmefumT5c2bJBuu827fMcdUqdOUpMm0ubN3sfNnu3tmzPHey/SzLeMGjDAO09Ws2beb5116eIdw1G4sPcvokWLpEGDvNs++KDUtKl00UXS3r1Sx47SlClSyZLSvHnSu+9KQ4Z4tx0+XEpNlS67zLvctq00caJUrpy0cKE0c6Y0apS374knpGrVpBEjvK/XsaP05JNS5crSkiXS8897HSVp7FgpKcnrLHnzPvSQVLOmdyLZJ57wOkve18vsLEk33ij16+eddHbVKmnwYK+z5H0fsZjXWZL69JF69JAaNpTWr/eaTp/u7Zs5U1q71vtcktS/v9Shg5SWJm3d6n29OXO8fa+/7j0OBgzwLg8cKF18sdS8ubRjh/d9TJ8uJSRIc+dKCxZ4nSXpkUe8+7B1a2n/fql9e2/exERp/nzpjTek117zmo0Y4T2O2rb1PrZdO2n8eKlCBW//1KleU0l6+mkpJcXrLEnXXCONHClVrSp98YX3cWPHevvGj/ce1126eJe7dZPuv1+qXdt7HD322MHOkydL+/Z5nSWpVy+vY2qqtGaNdN99XmfJm2frVm+/JN16q3T99VLjxt5juU+fg8cSzZ4tff+9dOed3uW77/a+z6ZNpW3bvJlmz5bi46U33/QeMwMHerd94AHpwgulFi2k3bu97/XVV6XFi6X335c+/FB6+GHvtkOGePf3pZdKGRlew8mTpTJlvPtlzhyvsyQ9/rhUq5Z3G8m7b0aP9rp+9pn0wgvSM894+0aP9h73nTp5l8P4HDF5sncfBP0c0aGDdzkMzxE9e3qPcSnY54jhw73bhuE5olYt7/uQgn2OmDZNKlYsHM8RRYtKX30V/HNEfllHHPocMXSo92cvT1w+E4vFnCQ2H7Y5c4KfIWwbzWhGs/y50YxmNMsfWywWy3Utx6mIIqxhQ+9flMg7mtnRzI5mdjSzo5kdzXLHqYgKuKZNg54gfGhmRzM7mtnRzI5mdjTzB4vLCLvooqAnCB+a2dHMjmZ2NLOjmR3N/MHiMsL27g16gvChmR3N7GhmRzM7mtnRzB8ccwkAAIA84ZjLAi7zNDXIO5rZ0cyOZnY0s6OZHc38weIywkqWDHqC8KGZHc3saGZHMzua2dHMHywuI2zevKAnCB+a2dHMjmZ2NLOjmR3N/MHiMsLefTfoCcKHZnY0s6OZHc3saGZHM3+wuIywzLd8Qt7RzI5mdjSzo5kdzexo5g8WlwAAAPANi8sIGz486AnCh2Z2NLOjmR3N7GhmRzN/sLiMsNTUoCcIH5rZ0cyOZnY0s6OZHc38YVpcPvjgg4qLi8u21a1bN2v/nj171Lt3b5UrV04lS5ZU+/bttWnTJt+HRt5cdlnQE4QPzexoZkczO5rZ0cyOZv4wv3J5xhlnaMOGDVnbxx9/nLXvjjvu0GuvvaYZM2Zo3rx5+umnn3TllVf6OjAAAADyMWcwePBg16BBgxz3bd++3RUpUsTNmDEj67ply5Y5SW7hwoV5/hqxWMxJYmNjY2NjY2Njy2dbLBbLdS1nfuVyxYoVqlSpkmrWrKnOnTtr7dq1kqTFixdr3759atWqVdZt69atq2rVqmnhwoVH/Xx79+5Venp6tg3+mDgx6AnCh2Z2NLOjmR3N7GhmRzN/mBaX55xzjiZPnqy3335bzz77rFavXq1mzZrp119/1caNG1W0aFGVLl0628dUrFhRGzduPOrnHDZsmJKSkrK2qlWrHtc3giOVKxf0BOFDMzua2dHMjmZ2NLOjmT8KW258ySWXZP3/WWedpXPOOUfVq1fX9OnTVaxYseMa4N5771W/fv2yLqenp7PA9MkxXjDGUdDMjmZ2NLOjmR3N7Gjmj991KqLSpUvrf/7nf7Ry5UolJyfrt99+0/bt27PdZtOmTUpOTj7q50hISFBiYmK2Df6YOTPoCcKHZnY0s6OZHc3saGZHM3/8rsXljh079P333yslJUWNGjVSkSJF9N5772XtX758udauXau0tLTfPSjsRo0KeoLwoZkdzexoZkczO5rZ0cwfph+L33nnnbr88stVvXp1/fTTTxo8eLAKFSqkTp06KSkpST169FC/fv1UtmxZJSYmqm/fvkpLS9O55557ouYHAABAfpLncwQ5566++mqXkpLiihYt6ipXruyuvvpqt3Llyqz9u3fvdrfccosrU6aMK168uGvXrp3bsGGD5UtwKiIft+bNg58hbBvNaEaz/LnRjGY0yx9bXk5FZHrlctq0acfcf8opp2jMmDEaM2aM5dPiBKlWLegJwodmdjSzo5kdzexoZkczf/De4hHWoUPQE4QPzexoZkczO5rZ0cyOZv5gcQkAAADfxDnnXNBDHCo9PV1JSUlBjxEJCQnS3r1BTxEuNLOjmR3N7GhmRzM7muUuFovletpIXrmMsCefDHqC8KGZHc3saGZHMzua2dHMHywuI6xy5aAnCB+a2dHMjmZ2NLOjmR3N/MHiMsKWLAl6gvChmR3N7GhmRzM7mtnRzB8ccxlhVatK69YFPUW40MyOZnY0s6OZHc3saJY7jrk0cM7luoXN6NFBTxA+NLOjmR3N7GhmRzM7mvmDxeUh3lrxltbFcv4ny7rYOqn2SR4IAAAgZEzv0BNlb614S1dMu0J1T6mij7e3V9ILL0s//SRVqqTY9Vfr0tKzpE6SpkpaGfS0eTN2bNAThA/N7GhmRzM7mtnRzI5m/mBx+V+pFVJV95QqmvTkDyq5cZT3DpqS9OOPKjlslCYlSxe2lXZuDnRMEw5dtaOZHc3saGZHMzua2dHMH/xY/L+qJlXVx9vbq+FGqdBhh1cWclLDjdIdkySlBzLecencOegJwodmdjSzo5kdzexoZkczf7C4PETSCy8fsbDMFO+kmzhrPwAAwDFxKqL/cs5JhQpJGRlHvc0Bhes4gsREKT1Er7TmBzSzo5kdzexoZkczO5rljlMRWVWqdNRdTtJPJ28SXzz0UNAThA/N7GhmRzM7mtnRzI5m/mBxeYjY9VfrQFzO+zLipOcSTu48v1fNmkFPED40s6OZHc3saGZHMzua+YPF5X+ti63T+aVnaUmydCDu4C+LO3mXlyRLT94g6divBOcry5YFPUH40MyOZnY0s6OZHc3saOYPjrnMVFtSJ6nEz95vhd+0V6ok70fhzyV4C8ud5RWq81xWqCBtDtGpk/IDmtnRzI5mdjSzo5kdzXKXl2Mu5fKZWCzm5L1gePK32nJKPMq+xP/uD2q249jmzAl+hrBtNKMZzfLnRjOa0Sx/bLFYLNe1XJh++fnEO9YrkukK1TkuAQAAgsAxlxE2cWLQE4QPzexoZkczO5rZ0cyOZv5gcQkAAADfsLiMsO7dg54gfGhmRzM7mtnRzI5mdjTzB4tLAAAA+IZTEUUYp1Swo5kdzexoZkczO5rZ0Sx3vP1jAdevX9AThA/N7GhmRzM7mtnRzI5m/mBxGWH16gU9QfjQzI5mdjSzo5kdzexo5g8WlxG2alXQE4QPzexoZkczO5rZ0cyOZv7gmMsIS0yU0jnxuwnN7GhmRzM7mtnRzI5mueOYywLuxReDniB8aGZHMzua2dHMjmZ2NPMHi0sAAAD4hsVlhE2ZEvQE4UMzO5rZ0cyOZnY0s6OZP1hcRlgsFvQE4UMzO5rZ0cyOZnY0s6OZP1hcRtgttwQ9QfjQzI5mdjSzo5kdzexo5g8WlwAAAPANpyKKsKpVpXXrgp4iXGhmRzM7mtnRzI5mdjTLHaciKuB69Ah6gvChmR3N7GhmRzM7mtnRzB8sLiOsYcOgJwgfmtnRzI5mdjSzo5kdzfzB4jLC1q8PeoLwoZkdzexoZkczO5rZ0cwfHHMZYQkJ0t69QU8RLjSzo5kdzexoZkczO5rljmMuC7jp04OeIHxoZkczO5rZ0cyOZnY08weLSwAAAPiGxWWEzZwZ9AThQzM7mtnRzI5mdjSzo5k/WFxG2Nq1QU8QPjSzo5kdzexoZkczO5r5g8VlhPXrF/QE4UMzO5rZ0cyOZnY0s6OZP1hcAgAAwDeciijCateWVq4MeopwoZkdzexoZkczO5rZ0Sx3nIqogOvQIegJwodmdjSzo5kdzexoZkczf7C4jLC0tKAnCB+a2dHMjmZ2NLOjmR3N/MHiMsK2bg16gvChmR3N7GhmRzM7mtnRzB8ccwkAAIA8ycsxl4VP0ixmU6dKxYtLnTtLQ4dK1atLS5dKo0dL48Z5t5kwQSpSROrWzbvcvbt0zz1SnTreAbmPPipNnuzte/FFadcuqWdP7/Itt3j/36CBtG6ddNdd0rRp3r7p06UNG6TbbvMu33GH1KmT1KSJtHmz93GzZ3v75syRli+X7r7buzxggNSmjdSsmZSeLnXpIs2aJRUuLL3zjrRokTRokHfbBx+UmjaVLrrIey/Tjh2lKVOkkiWlefOkd9+Vhgzxbjt8uJSaKl12mXe5bVtp4kSpXDlp4ULvxK+jRnn7nnhCqlZNGjHC+3odO0pPPilVriwtWSI9/7zXUZLGjpWSkrzOkjfvQw9JNWtKy5Z5n2vCBG/fxIkHO0vSjTd6p22oV09atUoaPNjrLHnfRyzmdZakPn2kHj2khg2l9eu9pplvszVzpnduscxTQPTv7x33kpbm/Suye3evsyS9/rr3OBgwwLs8cKB08cVS8+bSjh3e9zF9uvf+sHPnSgsWeJ0l6ZFHvPuwdWtp/36pfXtv3sREaf586Y03pPff95qNGOE9jtq29T62XTtp/HipQgVv/9SpXlNJevppKSXF6yxJ11wjjRwpVa0qffGF93Fjx3r7xo/3HtdduniXu3WT7r/fO4h8+XLpsccOdp48Wdq3z+ssSb16eR1TU6U1a6T77vM6S948W7d6+yXp1lul66+XGjf2Hst9+niPQ8l77H7/vXTnnd7lu+/2vs+mTaVt27yZZs+W4uOlN9/0HjMDB3q3feAB6cILpRYtpN27ve/1xx+lxYu9dh9+KD38sHfbIUO8+/vSS6WMDK/h5MlSmTLe/TJnjtdZkh5/XKpVy7uN5N03o0d7XT/7THrhBemZZ7x9o0d7j/tOnbzLYXyOmDHDuw+Cfo7IPL4sDM8RPXsefFUpyOeI4cO924bhOaJmTenAAW9fkM8R06ZJxYqF4zmiaFHpq6+Cf47IL+uIQ58jhg71/uzlictnYrGYk8TmwzZnTvAzhG2jGc1olj83mtGMZvlji8Viua7lOOYywl5/PegJwodmdjSzo5kdzexoZkczf7C4jLClS4OeIHxoZkczO5rZ0cyOZnY08weLywjLPOYIeUczO5rZ0cyOZnY0s6OZP1hcAgAAwDeciijCUlN5id+KZnY0s6OZHc3saGZHs9zx9o8F3MUXBz1B+NDMjmZ2NLOjmR3N7GjmDxaXEda8edAThA/N7GhmRzM7mtnRzI5m/mBxGWE7dgQ9QfjQzI5mdjSzo5kdzexo5g+OuQQAAECecMxlAZf51mnIO5rZ0cyOZnY0s6OZHc38weIywhISgp4gfGhmRzM7mtnRzI5mdjTzB4vLCJs7N+gJwodmdjSzo5kdzexoZkczf7C4jLAFC4KeIHxoZkczO5odm3NOb373ptZuXyvnnJxz+utfF2f9/9rta/Xmd28GPWa+x+PMjmY+cflMLBZzkth82ObMCX6GsG00oxnNgt/e/O5NV/jhwi51xGlu+339natSxbl/yrkqVdz2+/q71BGnucIPF3aqHfys+XnjcUazE7HFYrFc13KFBQBAPpJaIVV1T6miSU/+oJIbRx38a+3HH1Vy2ChNSpZuuOM0Ld38Q8CTAsjRSXgx0oRXLv3bGjcOfoawbTSjGc2C35xzbvt9/d3+ODmn/26ND/7//ji57ff1D3zO/L7xOKPZidjy8solx1xGWJMmQU8QPjSzo5kdzXKX9MLLKuQOueKQZvHO249j43FmRzN/sLiMsNatg54gfGhmRzM7muXBTz9lv3xIs7ic9uMIPM7saOYPFpcRtn9/0BOED83saGZHszyoVCn75UOauZz24wg8zuxo5g/e/hEAkK845xQbeKdKDhuV/Ufj/3UgTtpxb3+VHjrq5A8HFHC8/WMB9+KLQU8QPjSzo5kdzY5tXWydzi89S0uSvYWkk6QXvf8eiJOWJEvnl54lHfvvtwKPx5kdzfzBqYgiLJd/WCAHNLOjmR3Njm3p5qX6ds+PuuGO0/Tx9vbeL+8k/ai4KlW04/qrdUPpWfp2z49SBUnpQU+bf/E4s6OZP1hcRtj8+UFPED40s6OZHc2O7dL/uVSqLS3d/INKp3s/+r7zI+nxH3+Uho7yXrGsIGlloGPmezzO7GjmDxaXEfbGG0FPED40s6OZHc3y4LCFY7Zm6eIVyzzgcWZHM39wzGWEDR8e9AThQzM7mtnRzI5mdjSzo5k/WFwCAADANywuI2zEiKAnCB+a2dHMjmZ2NLOjmR3N/MHiMsLq1Al6gvChmR3N7GhmRzM7mtnRzB8sLiOsbdugJwgfmtnRzI5mdjSzo5kdzfzB4hIAAAC+4e0fIyw+XsrICHqKcKGZHc3saGZHMzua2dEsd7z9YwE3fnzQE4QPzexoZkczO5rZ0cyOZv4wLy7Xr1+v6667TuXKlVOxYsV05pln6rPPPsva75zTAw88oJSUFBUrVkytWrXSihUrfB0aeVOhQtAThA/N7GhmRzM7mtnRzI5m/jAtLrdt26amTZuqSJEieuutt/TNN99o1KhRKlOmTNZtRowYoWeeeUbjxo3Tp59+qhIlSqh169bas2eP78Pj2BYtCnqC8KGZHc3saGZHMzua2dHMJ87gnnvuceeff/5R92dkZLjk5GQ3cuTIrOu2b9/uEhIS3NSpU/P0NWKxmJPE5sNWs2bwM4RtoxnNaJY/N5rRjGb5Y4vFYrmu5UyvXP7zn/9U48aNddVVV6lChQpq2LChJkyYkLV/9erV2rhxo1q1apV1XVJSks455xwtXLjQ8qXggyefDHqC8KGZHc3saGZHMzua2dHMH6bF5apVq/Tss8/q9NNP1zvvvKObb75Zt956q/7+979LkjZu3ChJqlixYraPq1ixYta+w+3du1fp6enZNgAAAIRUnn5W/V9FihRxaWlp2a7r27evO/fcc51zzi1YsMBJcj/99FO221x11VWuY8eOOX7OwYMHB/4Sb1S3Fi2CnyFsG81oRrP8udGMZjTLH5vvPxZPSUlR/fr1s11Xr149rV27VpKUnJwsSdq0aVO222zatClr3+HuvfdexWKxrG3dunWWkXAMKSlBTxA+NLOjmR3N7GhmRzM7mvnDtLhs2rSpli9fnu267777TtWrV5ck1ahRQ8nJyXrvvfey9qenp+vTTz9VWlpajp8zISFBiYmJ2Tb4o2PHoCcIH5rZ0cyOZnY0s6OZHc38Udhy4zvuuEPnnXeehg4dqo4dO2rRokV67rnn9Nxzz0mS4uLidPvtt+vRRx/V6aefrho1amjQoEGqVKmS/vznP5+I+QEAAJCfWI65dM651157zaWmprqEhARXt25d99xzz2Xbn5GR4QYNGuQqVqzoEhISXMuWLd3y5cvz/Pk5FZF/W7Fiwc8Qto1mNKNZ/txoRjOa5Y8tL8dcmheXJxqLS/+20aODnyFsG81oRrP8udGMZjTLH5vvv9CDcKlaNegJwodmdjSzo5kdzexoZkczf7C4jLAvvgh6gvChmR3N7GhmRzM7mtnRzB9xzjkX9BCHSk9PV1JSUtBjRELlytL69UFPES40s6OZHc3saGZHMzua5S4Wi+V6Zh9euYywsWODniB8aGZHMzua2dHMjmZ2NPMHi0sAAAD4hsVlhI0fH/QE4UMzO5rZ0cyOZnY0s6OZP1hcRljx4kFPED40s6OZHc3saGZHMzua+YPFZYR16RL0BOFDMzua2dHMjmZ2NLOjmT9YXAIAAMA3nIoowsqUkbZtC3qKcKGZHc3saGZHMzua2dEsd5yKqIC7//6gJwgfmtnRzI5mdjSzo5kdzfzB4jLCatcOeoLwoZkdzexoZkczO5rZ0cwfLC4jbPnyoCcIH5rZ0cyOZnY0s6OZHc38wTGXEVaunLR1a9BThAvN7GhmRzM7mtnRzI5mueOYywJu4sSgJwgfmtnRzI5mdjSzo5kdzfzB4hIAAAC+YXEZYZMnBz1B+NDMjmZ2NLOjmR3N7GjmDxaXEbZvX9AThA/N7ApqM+ecnHN687s3tXb72qzLh25rt6+Vcvjt04La7PegmR3N7GjmDxaXEXbjjUFPED40syvIzd5a8ZaumHaFLn3uAsUG3ilVrSoVKiRVrarYwDt16XMXSJ10xAKzIDc7XjSzo5kdzfxROOgBACCsUiukqu4pVTTpyR9UcuMoKfPcGz/+qJLDRmlSsnRhW2nn5kDHBICTy+UzsVjMyXuKZvudW0pK8DOEbaMZzfK6Zdp+X3+3P07O6chtf5zc/Qk082OjGc1olj+2WCyW61qOH4tHWJ8+QU8QPjSzK+jNkl54WYVczvvinXTT3iOvL+jNjgfN7GhmRzN/sLiMsNTUoCcIH5rZFfhmP/101F1xkirlcH2Bb3YcaGZHMzua+YPFZYStWRP0BOFDM7sC36xSTstHj5OU09KzwDc7DjSzo5kdzfzB2z9GWMmS0o4dQU8RLjSzK6jNMp86YwPvVMlho3L80fiBOOnBotKjh/1ovKA2+z1oZkczO5rljrd/LOCmTAl6gvChmV1BbrYutk7nl56lJcneQjJzfenkXV6SLD15g6TDnocLcrPjRTM7mtnRzB/57lRE+eyF1FDbtSvoCcKHZnYFtVl6eroWrVqkZdvX6fqbq+md2BVKmvqKtGGDlJKiWKcrdX3SP7Vzx1rpVEnpBz+2oDb7PWhmRzM7muUuL+u0fPdj8R9//FFVq1YNegwAAAAcZt26dapSpcoxb5PvFpcZGRn66aefVKpUKcXFxUnyXiGoWrWq1q1bl+vP+eE/+geP+yBY9A8W/YNF/+Dlh/vAOadff/1VlSpVUnz8sY+qzHc/Fo+Pjz/qijgxMZEHdoDoHzzug2DRP1j0Dxb9gxf0fZDXX7jmF3oAAADgGxaXAAAA8E0oFpcJCQkaPHiwEhISgh6lQKJ/8LgPgkX/YNE/WPQPXtjug3z3Cz0AAAAIr1C8cgkAAIBwYHEJAAAA37C4BAAAgG9YXAIAAMA3oVhcjhkzRqeddppOOeUUnXPOOVq0aFHQI0XSRx99pMsvv1yVKlVSXFycXn311Wz7nXN64IEHlJKSomLFiqlVq1ZasWJFMMNG0LBhw3T22WerVKlSqlChgv785z9r+fLl2W6zZ88e9e7dW+XKlVPJkiXVvn17bdq0KaCJo+XZZ5/VWWedlXWS4rS0NL311ltZ+2l/cg0fPlxxcXG6/fbbs67jPjixHnzwQcXFxWXb6tatm7Wf/ife+vXrdd1116lcuXIqVqyYzjzzTH322WdZ+8Py93C+X1y+/PLL6tevnwYPHqz//Oc/atCggVq3bq3NmzcHPVrk7Ny5Uw0aNNCYMWNy3D9ixAg988wzGjdunD799FOVKFFCrVu31p49e07ypNE0b9489e7dW5988onmzp2rffv26eKLL9bOnTuzbnPHHXfotdde04wZMzRv3jz99NNPuvLKKwOcOjqqVKmi4cOHa/Hixfrss8/UokULtW3bVl9//bUk2p9M//73vzV+/HidddZZ2a7nPjjxzjjjDG3YsCFr+/jjj7P20f/E2rZtm5o2baoiRYrorbfe0jfffKNRo0apTJkyWbcJzd/DLp9r0qSJ6927d9blAwcOuEqVKrlhw4YFOFX0SXKzZ8/OupyRkeGSk5PdyJEjs67bvn27S0hIcFOnTg1gwujbvHmzk+TmzZvnnPN6FylSxM2YMSPrNsuWLXOS3MKFC4MaM9LKlCnj/va3v9H+JPr111/d6aef7ubOneuaN2/ubrvtNuccj/+TYfDgwa5BgwY57qP/iXfPPfe4888//6j7w/T3cL5+5fK3337T4sWL1apVq6zr4uPj1apVKy1cuDDAyQqe1atXa+PGjdnui6SkJJ1zzjncFydILBaTJJUtW1aStHjxYu3bty/bfVC3bl1Vq1aN+8BnBw4c0LRp07Rz506lpaXR/iTq3bu32rRpk621xOP/ZFmxYoUqVaqkmjVrqnPnzlq7dq0k+p8M//znP9W4cWNdddVVqlChgho2bKgJEyZk7Q/T38P5enG5ZcsWHThwQBUrVsx2fcWKFbVx48aApiqYMntzX5wcGRkZuv3229W0aVOlpqZK8u6DokWLqnTp0tluy33gn6+++kolS5ZUQkKCevXqpdmzZ6t+/fq0P0mmTZum//znPxo2bNgR+7gPTrxzzjlHkydP1ttvv61nn31Wq1evVrNmzfTrr7/S/yRYtWqVnn32WZ1++ul65513dPPNN+vWW2/V3//+d0nh+nu4cNADADhS7969tXTp0mzHO+HEq1Onjj7//HPFYjHNnDlTXbt21bx584Ieq0BYt26dbrvtNs2dO1ennHJK0OMUSJdccknW/5911lk655xzVL16dU2fPl3FihULcLKCISMjQ40bN9bQoUMlSQ0bNtTSpUs1btw4de3aNeDpbPL1K5ennnqqChUqdMRvo23atEnJyckBTVUwZfbmvjjx+vTpo9dff10ffPCBqlSpknV9cnKyfvvtN23fvj3b7bkP/FO0aFHVrl1bjRo10rBhw9SgQQM9/fTTtD8JFi9erM2bN+t///d/VbhwYRUuXFjz5s3TM888o8KFC6tixYrcBydZ6dKl9T//8z9auXIlfwZOgpSUFNWvXz/bdfXq1cs6NCFMfw/n68Vl0aJF1ahRI7333ntZ12VkZOi9995TWlpagJMVPDVq1FBycnK2+yI9PV2ffvop94VPnHPq06ePZs+erffff181atTItr9Ro0YqUqRItvtg+fLlWrt2LffBCZKRkaG9e/fS/iRo2bKlvvrqK33++edZW+PGjdW5c+es/+c+OLl27Nih77//XikpKfwZOAmaNm16xOnnvvvuO1WvXl1SyP4eDvo3inIzbdo0l5CQ4CZPnuy++eYbd9NNN7nSpUu7jRs3Bj1a5Pz6669uyZIlbsmSJU6Se+KJJ9ySJUvcmjVrnHPODR8+3JUuXdrNmTPHffnll65t27auRo0abvfu3QFPHg0333yzS0pKch9++KHbsGFD1rZr166s2/Tq1ctVq1bNvf/+++6zzz5zaWlpLi0tLcCpo2PAgAFu3rx5bvXq1e7LL790AwYMcHFxce7dd991ztE+CIf+trhz3AcnWv/+/d2HH37oVq9e7RYsWOBatWrlTj31VLd582bnHP1PtEWLFrnChQu7IUOGuBUrVrgpU6a44sWLu3/84x9ZtwnL38P5fnHpnHN//etfXbVq1VzRokVdkyZN3CeffBL0SJH0wQcfOElHbF27dnXOeadBGDRokKtYsaJLSEhwLVu2dMuXLw926AjJqb0kN2nSpKzb7N69291yyy2uTJkyrnjx4q5du3Zuw4YNwQ0dId27d3fVq1d3RYsWdeXLl3ctW7bMWlg6R/sgHL645D44sa6++mqXkpLiihYt6ipXruyuvvpqt3Llyqz99D/xXnvtNZeamuoSEhJc3bp13XPPPZdtf1j+Ho5zzrlgXjMFAABA1OTrYy4BAAAQLiwuAQAA4BsWlwAAAPANi0sAAAD4hsUlAAAAfMPiEgAAAL5hcQkAAADfsLgEAACAb1hcAgAAwDcsLgEAAOAbFpcAAADwDYtLAAAA+Ob/Ad2Bj6aLoc3DAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t = np.random.randint(0, 100)\n", + "# Example usage\n", + "predict_and_visualize(model, data_loader, train_dataset, img_idx=t)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Final Electron counting project/Post Training Analysis/20KFixed_Mixed_5_32by32_Tiles_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/All notebooks for Tiles/Model Training(Fixed)Experimental 13.ipynb b/All notebooks for Tiles/Model Training(Fixed)Experimental 13.ipynb new file mode 100644 index 0000000..66e2440 --- /dev/null +++ b/All notebooks for Tiles/Model Training(Fixed)Experimental 13.ipynb @@ -0,0 +1,8109 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-24 19:16:12.136424: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-09-24 19:16:12.148999: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-09-24 19:16:12.161759: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-09-24 19:16:12.165630: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-09-24 19:16:12.176497: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-09-24 19:16:12.879734: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device /gpu:4\n" + ] + } + ], + "source": [ + "import os\n", + "import tensorflow as tf\n", + "\n", + "# Set CUDA device order and visible devices\n", + "os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2,3,4,5,6,7,8,9\"\n", + "\n", + "# Set the device\n", + "device = '/cpu:0'\n", + "if tf.config.experimental.list_physical_devices('GPU'):\n", + " try:\n", + " # Restrict TensorFlow to only use the second GPU\n", + " gpus = tf.config.experimental.list_physical_devices('GPU')\n", + " if gpus:\n", + " tf.config.experimental.set_visible_devices(gpus[4], 'GPU')\n", + " device = '/gpu:4'\n", + " except RuntimeError as e:\n", + " print(e)\n", + "\n", + "print(\"device\", device)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# import os\n", + "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "# import tensorflow as tf\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\", \"/gpu:1\",\"/gpu:2\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# -----------------------------\n", + "# DataLoader Class Definition\n", + "# -----------------------------\n", + "class DataLoader:\n", + " def __init__(self, h5_filename):\n", + " self.h5_filename = h5_filename\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def plot_image_with_centers(self, image_index=None):\n", + " if image_index is None:\n", + " image_index = np.random.randint(0, len(self.images))\n", + "\n", + " image = self.images[image_index]\n", + " centers = self.centers[image_index]\n", + "\n", + " plt.imshow(image, cmap='gray')\n", + " valid_centers = centers[centers[:, 0] == 1]\n", + " for center in valid_centers:\n", + " plt.scatter(center[1], center[2], c='red', marker='x') # center[1] is x and center[2] is y\n", + " plt.title('Image with Valid Centers Marked')\n", + " plt.colorbar()\n", + " plt.show()\n", + "\n", + " @staticmethod\n", + " def sort_centers(centers):\n", + " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + " def normalize_data(self):\n", + " normalized_images = self.images / np.max(self.images)\n", + " sorted_centers = np.array([self.sort_centers(image_centers[:, 1:]) for image_centers in self.centers])\n", + " normalized_centers = sorted_centers / 64\n", + "\n", + " normalized_midpoints = tf.expand_dims(normalized_centers, axis=1)\n", + " return normalized_images, normalized_midpoints.numpy()\n", + "\n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_midpoints_np = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_midpoints_np, train_size=train_size, random_state=random_state)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# -----------------------------\n", + "# Utility Function Definition\n", + "# -----------------------------\n", + "def plot_transposed_images_with_midpoints(dataset, image_indices=[0, 1, 2, 3]):\n", + " \"\"\"\n", + " Extracts multiple images and their midpoints from the given dataset, transposes the images, \n", + " corrects the midpoints, and plots the transposed images with the corrected midpoints.\n", + "\n", + " Args:\n", + " - dataset (tf.data.Dataset): The dataset from which to extract the images and midpoints.\n", + " - image_indices (list): The indices of the images in the batch to visualize. Default is [0, 1, 2, 3].\n", + " \"\"\"\n", + "\n", + " # Extract a sample image batch and its corresponding midpoints from the dataset\n", + " sample_image_batch, sample_midpoints_batch = next(iter(dataset))\n", + "\n", + " # Create a figure with 2x2 subplots\n", + " fig, axes = plt.subplots(2, 2, figsize=(6, 6))\n", + "\n", + " for i, ax in enumerate(axes.flat):\n", + " if i < len(image_indices):\n", + " # Select the specified image and corresponding midpoints from the batch\n", + " sample_image = np.array(sample_image_batch[image_indices[i]])\n", + " sample_midpoints = np.array(sample_midpoints_batch[image_indices[i]])\n", + "\n", + " # Transpose the image\n", + " transposed_image = sample_image.T\n", + "\n", + " # Correct the midpoints by swapping the x and y coordinates\n", + " transposed_midpoints_corrected = sample_midpoints[:, :, [1, 0]]\n", + "\n", + " # Plot the transposed image with corrected midpoints\n", + " ax.imshow(transposed_image, cmap='gray')\n", + " ax.scatter(\n", + " transposed_midpoints_corrected[:, :, 0] * 64, \n", + " transposed_midpoints_corrected[:, :, 1] * 64, \n", + " c='red', marker='o', s=5\n", + " )\n", + " ax.set_title(f'Image {image_indices[i]} for this batch')\n", + " else:\n", + " ax.axis('off') # If fewer than 4 images are requested, hide the unused subplots\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# -----------------------------\n", + "# Custom Loss and Callback Definitions\n", + "# -----------------------------\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def custom_loss(exponent):\n", + " def loss(y_true, y_pred):\n", + " diff = tf.abs(y_true - y_pred)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " return tf.reduce_mean(powered_diff)\n", + " return loss\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "class DynamicExponentCallback(tf.keras.callbacks.Callback):\n", + " def __init__(self, initial_exponent, increment, update_frequency):\n", + " super().__init__()\n", + " self.exponent = initial_exponent\n", + " self.increment = increment\n", + " self.update_frequency = update_frequency\n", + "\n", + " def on_epoch_end(self, epoch, logs=None):\n", + " if (epoch + 1) % self.update_frequency == 0:\n", + " self.exponent += self.increment\n", + " print(f\"\\nEpoch {epoch + 1}: Increasing exponent to {self.exponent}\")\n", + " self.model.loss = self.custom_loss(self.exponent)\n", + "\n", + " def custom_loss(self, exponent):\n", + " def loss(y_true, y_pred):\n", + " diff = tf.abs(y_true - y_pred)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " return tf.reduce_mean(powered_diff)\n", + " return loss\n", + "\n", + " def get_config(self):\n", + " config = super().get_config().copy()\n", + " config.update({\n", + " 'initial_exponent': self.exponent,\n", + " 'increment': self.increment,\n", + " 'update_frequency': self.update_frequency,\n", + " })\n", + " return config\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "My model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# class ModelBuilder:\n", + "# def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=1e-3, weights_path=None):\n", + "# self.input_shape = input_shape\n", + "# self.num_classes = num_classes\n", + "# self.num_coordinates = num_coordinates\n", + "# self.learning_rate = learning_rate\n", + "# self.model = self.build_model()\n", + "\n", + "# # Load weights if a path is provided\n", + "# if weights_path is not None:\n", + "# self.model.load_weights(weights_path)\n", + "\n", + "# self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", + "# # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", + "\n", + "# def build_model(self):\n", + "# x_input = layers.Input(shape=self.input_shape)\n", + "# x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x_input)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.BatchNormalization()(x)\n", + "# x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x)\n", + " \n", + "# x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.Dropout(0.05)(x)\n", + "# x = layers.BatchNormalization()(x)\n", + " \n", + " \n", + "# x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.Dropout(0.05)(x)\n", + "# x = layers.BatchNormalization()(x)\n", + " \n", + " \n", + "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.Dropout(0.1)(x)\n", + "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.Dropout(0.1)(x)\n", + " \n", + "# x = layers.Conv2D(256, kernel_size=5, padding='same', activation='relu')(x)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.BatchNormalization()(x)\n", + "# # x = layers.Dropout(0.1)(x)\n", + " \n", + "# x = layers.Flatten()(x)\n", + " \n", + " \n", + " \n", + "# x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", + "# x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", + " \n", + "# return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", + "\n", + "# def compile_model(self, loss_function):\n", + "# self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", + "\n", + "# def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", + "# history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", + "# return history\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Josh's model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# class ModelBuilder:\n", + "# def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=1e-2, weights_path=None):\n", + "# self.input_shape = input_shape\n", + "# self.num_classes = num_classes\n", + "# self.num_coordinates = num_coordinates\n", + "# self.learning_rate = learning_rate\n", + "# self.model = self.build_model()\n", + "\n", + "# # Load weights if a path is provided\n", + "# if weights_path is not None:\n", + "# self.model.load_weights(weights_path)\n", + "\n", + "# self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", + "# # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", + "\n", + "# def build_model(self):\n", + "# x_input = layers.Input(shape=self.input_shape)\n", + "# x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x_input)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.BatchNormalization()(x)\n", + "# x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x)\n", + " \n", + "# x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.BatchNormalization()(x)\n", + " \n", + " \n", + "# x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.BatchNormalization()(x)\n", + " \n", + " \n", + "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.BatchNormalization()(x)\n", + "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.BatchNormalization()(x)\n", + "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.BatchNormalization()(x)\n", + " \n", + " \n", + "# x = layers.Conv2D(256, kernel_size=5, padding='same', activation='relu')(x)\n", + "# x = layers.MaxPool2D()(x)\n", + "# x = layers.BatchNormalization()(x)\n", + " \n", + " \n", + "# x = layers.Flatten()(x)\n", + " \n", + "# x = layers.Dense(256, activation='relu')(x)\n", + "# x = layers.Dropout(0.1)(x)\n", + "# x = layers.Dense(128, activation='relu')(x)\n", + "# x = layers.Dropout(0.1)(x)\n", + "# x = layers.Dense(64, activation='relu')(x)\n", + " \n", + "# x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", + "# x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", + " \n", + "# return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", + "\n", + "# def compile_model(self, loss_function):\n", + "# self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", + "\n", + "# def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", + "# history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", + "# return history\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class ModelBuilder:\n", + " def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=1e-3, weights_path=None):\n", + " self.input_shape = input_shape\n", + " self.num_classes = num_classes\n", + " self.num_coordinates = num_coordinates\n", + " self.learning_rate = learning_rate\n", + " self.model = self.build_model()\n", + "\n", + " # Load weights if a path is provided\n", + " if weights_path is not None:\n", + " self.model.load_weights(weights_path)\n", + "\n", + " self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", + " # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", + "\n", + " def build_model(self):\n", + " x_input = layers.Input(shape=self.input_shape)\n", + " \n", + " x_1 = layers.Conv2D(64, kernel_size=6,strides =3, padding='same', activation='relu')(x_input)\n", + " x_2 = layers.Conv2D(128, kernel_size=8,strides =3, padding='same', activation='relu')(x_input)\n", + " x_3 = layers.Conv2D(256, kernel_size=19,strides =3, padding='same', activation='relu')(x_input)\n", + " \n", + " x = layers.concatenate([x_1, x_2, x_3])\n", + " x = layers.Flatten()(x)\n", + " \n", + " x = layers.Dense(128, activation='relu')(x)\n", + " # x = layers.Dropout(0.1)(x)\n", + " x = layers.Dense(64, activation='relu')(x)\n", + " # x = layers.Dropout(0.1)(x)\n", + " x = layers.Dense(64, activation='relu')(x)\n", + " \n", + " \n", + " \n", + " \n", + " x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", + " x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", + " \n", + " return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", + "\n", + " def compile_model(self, loss_function):\n", + " self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", + "\n", + " def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", + " history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", + " return history\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# -----------------------------\n", + "# Main Script Execution\n", + "# -----------------------------\n", + "\n", + "# Load data\n", + "h5_filename = '/home/da886/Final Electron counting project/Images and Labels/12KFixed_Mixed_13_SparsespotsRandomIndex.h5' \n", + "\n", + "data_loader = DataLoader(h5_filename)\n", + "images, centers = data_loader.load_data()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "l=np.random.randint(0,len(centers))\n", + "data_loader.plot_image_with_centers(l)\n", + "plt.imshow(images[l])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-24 19:18:20.032251: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 4, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:4f:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "\n", + "# Normalize the data and split it into training and validation sets\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Images: (24000, 64, 64), Train Midpoints: (24000, 1, 5, 2)\n", + "Validation Images: (6000, 64, 64), Validation Midpoints: (6000, 1, 5, 2)\n" + ] + } + ], + "source": [ + "\n", + "batch_size = 800\n", + "train_dataset = train_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=True).batch(batch_size)\n", + "val_dataset = val_dataset.shuffle(buffer_size=8000).batch(batch_size)\n", + "\n", + "# Check the shape of the datasets\n", + "print(f'Train Images: {train_images.shape}, Train Midpoints: {train_midpoints.shape}')\n", + "print(f'Validation Images: {val_images.shape}, Validation Midpoints: {val_midpoints.shape}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_transposed_images_with_midpoints(train_dataset, image_indices=[0, 1, 2, 3])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Set up learning rate scheduler\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(\n", + " monitor='val_loss', factor=0.8, patience=10, verbose=1, mode='min', min_lr=7e-8\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "##### used this initially \n", + "# class DynamicHuberLoss(tf.keras.losses.Loss):\n", + "# def __init__(self, initial_delta, final_delta, total_epochs, **kwargs):\n", + "# super().__init__(**kwargs)\n", + "# self.initial_delta = initial_delta\n", + "# self.final_delta = final_delta\n", + "# self.total_epochs = total_epochs\n", + "# self.current_epoch = 0\n", + "\n", + "# def call(self, y_true, y_pred):\n", + "# # Compute current delta\n", + "# delta = self.initial_delta - ((self.initial_delta - self.final_delta) * (self.current_epoch / self.total_epochs))\n", + "# # Compute Huber loss with current delta\n", + "# return tf.keras.losses.huber(y_true, y_pred, delta=delta)\n", + "\n", + "# def update_epoch(self, epoch):\n", + "# self.current_epoch = epoch\n", + "\n", + "class DynamicHuberLoss(tf.keras.losses.Loss):\n", + " def __init__(self, initial_delta=1.0, final_delta=0.5, total_epochs=450, **kwargs):\n", + " super().__init__(**kwargs)\n", + " self.initial_delta = initial_delta\n", + " self.final_delta = final_delta\n", + " self.total_epochs = total_epochs\n", + " self.current_epoch = 0\n", + "\n", + " def call(self, y_true, y_pred):\n", + " # Dynamically adjust delta based on the current epoch\n", + " delta = self.initial_delta - ((self.initial_delta - self.final_delta) * (self.current_epoch / self.total_epochs))\n", + " error = y_true - y_pred\n", + " abs_error = tf.abs(error)\n", + " quadratic = tf.minimum(abs_error, delta)\n", + " linear = abs_error - quadratic\n", + " loss = 0.5 * quadratic**2 + delta * linear\n", + " return tf.reduce_mean(loss)\n", + "\n", + " def update_epoch(self, epoch):\n", + " self.current_epoch = epoch" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate the dynamic Huber loss\n", + "dynamic_huber_loss = DynamicHuberLoss(initial_delta=1.0, final_delta=0.5, total_epochs=450)\n", + "\n", + "\n", + "\n", + "# Create a custom callback to update the epoch\n", + "class UpdateEpochCallback(tf.keras.callbacks.Callback):\n", + " def __init__(self, loss_fn):\n", + " super().__init__()\n", + " self.loss_fn = loss_fn\n", + " self.current_epoch = 0\n", + "\n", + " def on_epoch_begin(self, epoch, logs=None):\n", + " self.loss_fn.update_epoch(epoch)\n", + "\n", + "# Instantiate the callback\n", + "update_epoch_callback = UpdateEpochCallback(dynamic_huber_loss)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional_2\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional_2\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)        ┃ Output Shape      ┃    Param # ┃ Connected to      ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_2       │ (None, 64, 64, 1) │          0 │ -                 │\n",
+       "│ (InputLayer)        │                   │            │                   │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ conv2d_6 (Conv2D)   │ (None, 22, 22,    │      2,368 │ input_layer_2[0]… │\n",
+       "│                     │ 64)               │            │                   │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ conv2d_7 (Conv2D)   │ (None, 22, 22,    │      8,320 │ input_layer_2[0]… │\n",
+       "│                     │ 128)              │            │                   │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ conv2d_8 (Conv2D)   │ (None, 22, 22,    │     92,672 │ input_layer_2[0]… │\n",
+       "│                     │ 256)              │            │                   │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ concatenate_2       │ (None, 22, 22,    │          0 │ conv2d_6[0][0],   │\n",
+       "│ (Concatenate)       │ 448)              │            │ conv2d_7[0][0],   │\n",
+       "│                     │                   │            │ conv2d_8[0][0]    │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ flatten_2 (Flatten) │ (None, 216832)    │          0 │ concatenate_2[0]… │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ dense_6 (Dense)     │ (None, 128)       │ 27,754,624 │ flatten_2[0][0]   │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ dense_7 (Dense)     │ (None, 64)        │      8,256 │ dense_6[0][0]     │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ dense_8 (Dense)     │ (None, 64)        │      4,160 │ dense_7[0][0]     │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ x_midpoints (Dense) │ (None, 10)        │        650 │ dense_8[0][0]     │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ x_midpoints_reshape │ (None, 1, 5, 2)   │          0 │ x_midpoints[0][0] │\n",
+       "│ (Reshape)           │                   │            │                   │\n",
+       "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n", + "│ input_layer_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "│ (\u001b[38;5;33mInputLayer\u001b[0m) │ │ │ │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ conv2d_6 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m22\u001b[0m, │ \u001b[38;5;34m2,368\u001b[0m │ input_layer_2[\u001b[38;5;34m0\u001b[0m]… │\n", + "│ │ \u001b[38;5;34m64\u001b[0m) │ │ │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ conv2d_7 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m22\u001b[0m, │ \u001b[38;5;34m8,320\u001b[0m │ input_layer_2[\u001b[38;5;34m0\u001b[0m]… │\n", + "│ │ \u001b[38;5;34m128\u001b[0m) │ │ │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ conv2d_8 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m22\u001b[0m, │ \u001b[38;5;34m92,672\u001b[0m │ input_layer_2[\u001b[38;5;34m0\u001b[0m]… │\n", + "│ │ \u001b[38;5;34m256\u001b[0m) │ │ │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ concatenate_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m22\u001b[0m, \u001b[38;5;34m22\u001b[0m, │ \u001b[38;5;34m0\u001b[0m │ conv2d_6[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ (\u001b[38;5;33mConcatenate\u001b[0m) │ \u001b[38;5;34m448\u001b[0m) │ │ conv2d_7[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", + "│ │ │ │ conv2d_8[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ flatten_2 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m216832\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ concatenate_2[\u001b[38;5;34m0\u001b[0m]… │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ dense_6 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m27,754,624\u001b[0m │ flatten_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ dense_7 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m8,256\u001b[0m │ dense_6[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ dense_8 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m4,160\u001b[0m │ dense_7[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ x_midpoints (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m650\u001b[0m │ dense_8[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ x_midpoints_reshape │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ x_midpoints[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │ │\n", + "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 27,871,050 (106.32 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m27,871,050\u001b[0m (106.32 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 27,871,050 (106.32 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m27,871,050\u001b[0m (106.32 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dynamic_exponent_callback = DynamicExponentCallback(1, 1, 50)\n", + "# Initialize the ModelBuilder within the strategy scope\n", + "\n", + "# Instantiate the model builder\n", + "model_builder = ModelBuilder()\n", + "\n", + "# Build the model\n", + "model_builder.build_model()\n", + "\n", + "# Display the model architecture\n", + "model_builder.model.summary()\n", + "\n", + "# Compile the model\n", + "model_builder.compile_model(loss_function=dynamic_exponent_callback.custom_loss(1))\n", + " # If using a custom loss function, replace the above line with:\n", + " # model_builder.compile_model(loss_function=custom_loss(exponent=2))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:23:15.949285: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-09-23 15:23:15.961632: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-09-23 15:23:15.996505: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1727104996.051192 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.053565 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.061265 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.118799 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.118780 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.118828 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.119715 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.119735 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.119819 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.125318 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.125324 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.125837 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.142586 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.142821 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.142951 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.145096 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.145160 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.145738 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.146416 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.146490 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.146799 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.147579 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.147673 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.147906 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.150187 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.150445 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.150875 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.167477 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.167579 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.167609 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.168795 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.168949 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.168994 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.169788 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.170138 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.170157 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.170971 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.171445 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.171468 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.172105 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.172708 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.172730 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.173487 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.174279 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.174303 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.176281 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.176433 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.176462 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.178942 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.179147 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.179245 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.182481 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.182490 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.182590 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.186548 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.186545 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.186662 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.191621 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.191843 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.191913 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.194230 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.194238 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.194348 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.202371 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.202379 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.202491 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.205666 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.205715 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.205833 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.600170 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.601030 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.601794 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.602536 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.603390 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.604533 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.605928 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.607297 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.608663 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.610133 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.612892 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.615321 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.630301 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.630867 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.631479 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.632115 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.632781 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.633444 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.634129 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.634876 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.636616 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.637454 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.638287 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.639470 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.645972 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.646917 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.647757 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.651098 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.652846 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.654739 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.656317 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.658141 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.660124 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.670193 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.671087 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.672037 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.672887 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.673721 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.675001 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.677473 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.679953 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.682393 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.684789 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.687196 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.689825 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.719336 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.720033 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.720792 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.721686 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.722607 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.723585 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.724598 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.725593 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.726774 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.727913 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.729175 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.732394 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.736730 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.738200 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.739544 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.741215 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.742820 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.744248 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.747043 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.750418 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.761854 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.763097 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.764518 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.765726 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.766904 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.768868 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.773529 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.778128 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.782798 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.787956 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.792486 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.797498 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.841982 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.842835 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.843608 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.844361 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.845229 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.846394 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.847810 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.849193 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.850581 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.852059 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.854509 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.859481 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.860582 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.861706 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.861821 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.863191 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.864557 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.865946 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.867537 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.868985 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.870711 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.871346 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.872197 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.872521 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.872984 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.873740 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.874309 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.874621 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.875763 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.876877 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.877201 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.877493 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.878123 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.878655 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.878848 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.879693 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.879813 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.880078 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.880401 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.881103 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.881575 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.881861 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.882825 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.883667 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.884050 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.884916 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.885839 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.886829 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.887142 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.887861 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.888836 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.889077 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.889740 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.891320 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.892564 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.894002 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.894024 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.895236 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.897036 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.897058 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.898908 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.899541 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.900932 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.902215 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.902786 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.903425 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.904075 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.904870 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.904970 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.905638 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.906318 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.907053 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.907936 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.908751 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.909585 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.910469 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.910926 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.911849 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.912849 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.913180 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.913722 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.914132 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.914603 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.914998 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.915996 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.917881 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.918507 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.919048 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.920261 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.921025 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.921593 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.921861 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.923673 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.923898 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.923926 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.925605 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.925908 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.926139 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.927657 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.928591 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.929673 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.931285 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.932110 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.934062 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.936033 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.936269 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.936965 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.937928 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.938780 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.939199 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.939631 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.940910 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.941201 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.943556 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.943586 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.946073 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.948533 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.950967 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.952663 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.953414 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.956058 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.961090 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.961629 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.961826 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.962595 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.963485 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.964422 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.965405 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.966420 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.967416 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.968610 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.969758 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.970739 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.971047 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.974305 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.978663 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.979709 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.980167 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.981518 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.983198 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.984819 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.985702 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.986332 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.986507 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.987276 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.988162 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.988628 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.989276 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.989351 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.990291 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.991306 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.992302 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.992796 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.993516 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.994655 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.995895 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.998381 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104996.999154 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.003510 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.004103 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.004981 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.005378 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.006342 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.006833 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.008384 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.008406 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.008431 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.009621 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.010022 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.011495 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.011679 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.014326 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.016409 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.017732 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.021074 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.025810 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.029170 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.030555 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.030626 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.032050 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.033267 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.034451 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.035161 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.036443 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.040243 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.041166 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.045797 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.050517 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.055087 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.059665 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.064670 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.099198 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.100275 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.101439 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.102742 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.104109 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.105520 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.106972 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.108437 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.110168 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.111926 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.113717 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.119124 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.123334 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.124410 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.124978 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.125592 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.126165 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.127154 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.127175 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.128442 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.128612 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.129397 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.130029 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.130701 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.131628 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.131759 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.133274 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.133298 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.134244 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.135023 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.136080 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.136650 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.136816 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.138746 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.139043 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.139478 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.141804 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.144506 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.144677 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.144698 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.148436 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.151690 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.151787 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.154036 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.154898 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.156297 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.158105 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.158750 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.161197 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.161519 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.163268 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.164119 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.164221 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.164970 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.166999 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.168264 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.169011 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.169528 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.171459 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.172784 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.173435 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.175655 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.176891 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.178001 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.179999 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.180374 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.182384 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.186325 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.188401 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.190104 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.191660 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.192169 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.193188 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.194642 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.196662 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.198382 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.198649 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.201054 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.201379 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.203289 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.203459 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.205466 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.207712 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.210800 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.213509 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.216829 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.219927 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.223612 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.226068 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.229038 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.235319 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.238876 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.244435 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.247179 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.248640 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.250512 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.253630 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.253738 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.256985 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.260272 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.263606 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.264497 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.267701 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.271486 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.273393 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.275344 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.278635 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.282428 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.300891 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.319718 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.338163 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.355966 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.366085 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.368086 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.370295 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.372498 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.373615 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.374978 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.377308 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.380021 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.382311 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.384813 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.387815 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.390804 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.390907 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.392207 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.392831 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.394157 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.395064 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.397434 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.397530 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.399914 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.402241 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.403420 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.404962 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.407267 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.407592 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.409800 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.411344 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.412160 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.412815 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.415821 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.416310 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.418932 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.419825 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.422029 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.427632 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.431610 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.432724 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.436052 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.437945 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.440066 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.442854 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.443474 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.453170 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.456064 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.461097 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.463426 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.465874 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.475956 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.486295 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.488447 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.491780 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.494712 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.498045 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.501323 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.505536 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.508729 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.510177 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.512461 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.513532 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.516328 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.516544 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.519689 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.519926 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.523235 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.523586 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.527488 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.530744 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.534593 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.538452 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.541776 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.542113 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.545640 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.560778 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.564953 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.579208 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.583783 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.596920 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.602334 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.614533 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.620466 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.633253 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.638319 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.642269 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.645604 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.649217 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.652717 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.652832 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.656784 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.657540 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.660629 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.664705 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.668546 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.672718 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.676278 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.677305 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.682735 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.688181 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.693932 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.702621 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.709931 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.717665 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.725494 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.731751 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.755183 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.765031 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.774230 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.800312 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.806322 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.812413 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.817734 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.825949 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.832029 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.839396 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.845897 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.852264 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.859758 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.867599 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.885272 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.888627 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.892253 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.895771 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.899708 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.903541 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.906428 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.907809 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.908157 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.911642 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.911762 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.915302 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.915946 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.918853 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.920514 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.922808 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.925912 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.926668 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.930744 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.931383 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.934829 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.937181 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.939269 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.942608 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.943852 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.945934 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.949228 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.953323 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.954780 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.960674 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.961037 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.968811 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.969615 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.975025 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.977040 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.978307 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.984825 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.992663 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.997991 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104997.998857 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.007655 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.013057 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.016948 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.021988 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.031665 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.041105 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.042659 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.048513 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.048840 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.054933 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.060276 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.067942 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.068625 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.074055 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.074830 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.080228 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.082383 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.084979 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.085624 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.089018 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.093690 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.095521 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.100054 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.103113 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.107677 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.113181 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.114397 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.120889 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.122575 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.128418 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.136260 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.151834 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.174916 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.187769 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.210991 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.223857 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.246928 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.258861 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.281345 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.294529 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.316727 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.331314 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.353302 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.368941 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.391020 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.582494 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.589012 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.595041 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.601760 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.609853 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.617342 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.625159 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.633842 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.641687 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.650216 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.660577 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.671130 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.682314 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.694163 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.708625 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.723622 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.737953 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.756545 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.775119 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.810927 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.831340 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.837841 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.843890 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.850609 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.852445 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.858394 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.858999 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.863224 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.865105 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.865742 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.866911 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.869699 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.871907 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.872720 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.873892 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.875793 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.878719 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.879711 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.882999 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.883017 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.886658 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.887641 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.889777 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.890930 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.893457 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.895863 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.897136 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.899656 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.904767 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.910248 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.912760 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.916689 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.920963 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.921519 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.932457 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.932464 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.936111 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.943335 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.944397 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.954871 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.954901 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.958525 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.966809 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.972826 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.975748 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.981484 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.990143 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.990565 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104998.996384 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.008525 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.009112 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.010833 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.027224 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.028475 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.029678 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.048476 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.063015 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.084979 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.114861 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.118719 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.121464 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.124401 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.127409 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.130469 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.134618 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.137937 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.138358 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.141406 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.141521 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.144259 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.145166 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.147324 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.148777 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.150311 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.153397 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.157448 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.160983 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.164105 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.167798 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.168383 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.171465 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.187672 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.191223 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.206268 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.210782 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.224170 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.229493 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.241842 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.247362 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.260535 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.265041 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.280079 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.282719 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.283618 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.285983 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.289055 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.292274 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.295715 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.299126 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.302536 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.302906 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.306151 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.309712 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.313679 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.318482 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.323319 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.328613 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.334301 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.341086 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.348070 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.355648 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.364695 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.374070 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.392159 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.417511 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.418448 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.419390 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.420601 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.421554 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.422475 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.423668 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.424723 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.425759 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.426842 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.427884 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.432756 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.437463 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.442116 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.446942 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.451886 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.456789 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.462004 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.528194 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.529256 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.530222 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.531240 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.532319 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.533370 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.534429 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.535123 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.535510 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.536644 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.537768 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.538407 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.539108 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.540424 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.541510 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.541878 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.543489 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.544762 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.545264 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.547083 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.548247 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.549105 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.551424 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.551747 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.555271 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.555983 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.558031 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.559023 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.561199 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.561373 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.562689 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.564517 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.566559 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.567798 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.571359 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.571430 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.574853 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.576279 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.578428 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.581755 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.582051 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.585079 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.585860 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.585960 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.586449 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.587000 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.587939 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.587955 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.589952 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.590663 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.593843 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.594948 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.595029 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.596679 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.599796 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.600300 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.602143 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.604342 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.605166 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.609314 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.610045 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.611035 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.612452 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.618026 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.619248 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.625217 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.626901 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.627481 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.628011 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.628630 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.628833 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.629307 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.629909 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.630581 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.631210 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.631894 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.632505 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.632925 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.633228 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.633942 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.634526 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.635114 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.637792 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.638414 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.640704 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.641582 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.642179 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.642881 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.643994 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.647016 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.651700 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.670120 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.673041 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.673992 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.674922 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.676126 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.677070 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.677978 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.679148 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.680187 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.681206 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.682280 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.683305 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.688132 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.692831 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.696320 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.697358 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.697526 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.698333 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.699558 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.700524 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.701457 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.702319 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.702683 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.703744 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.704789 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.705868 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.706902 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.707236 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.711786 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.712149 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.716552 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.717349 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.721270 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.726113 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.731063 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.736028 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.741267 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.783887 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.784937 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.785900 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.786903 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.787968 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.788993 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.790050 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.791106 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.792235 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.793351 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.794665 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.795971 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.797396 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.798989 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.800706 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.802491 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.804482 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.806784 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.807521 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.808577 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.809558 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.810561 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.811335 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.811831 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.812885 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.813948 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.815001 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.816133 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.816431 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.817288 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.818615 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.819941 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.821366 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.822970 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.824722 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.826531 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.828536 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.830858 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.835465 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.840366 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.840552 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.840997 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.842183 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.842737 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.843360 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.846070 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.849262 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.852086 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.855706 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.859779 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.863932 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.864862 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.865494 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.866059 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.866606 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.867134 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.867305 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.870006 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.873197 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.876023 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.879644 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.881741 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.882310 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.882825 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.883373 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.883713 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.884194 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.884790 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.885451 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.886070 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.886748 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.887359 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.887929 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.888108 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.888820 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.889405 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.889990 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.891087 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.892696 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.893314 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.895601 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.896473 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.897755 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.898873 2784947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.905648 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.906207 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.906731 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.907280 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.908011 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.908609 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.909296 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.911853 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.912547 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.913165 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.913870 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.914584 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.915167 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.915753 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.918428 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.919043 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.921318 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.922192 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.923482 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727104999.924581 2784958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.348668 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.351136 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.351733 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.352305 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.352885 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.355282 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.355846 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.356430 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.357285 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.358042 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.360245 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.360857 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.361662 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.362387 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.363073 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.363728 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.365846 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.368152 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.370841 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.373470 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.381713 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.395183 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.434363 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.434975 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.435521 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.437901 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.438473 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.439053 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.439612 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.441540 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.443846 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.445411 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.446028 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.446627 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.447293 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.447946 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.448688 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.449423 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.451087 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.451849 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.452624 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.453392 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.463063 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.471954 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.512796 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.513496 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.515492 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.516051 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.516619 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.517227 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.517822 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.518392 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.518990 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.519592 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.520277 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.520948 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.521840 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.522454 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.523062 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.523676 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.524264 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.524984 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.525722 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.526481 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.527119 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.527916 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.528897 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.529572 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.532165 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.535902 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.538137 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.545412 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.552165 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.558856 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.565550 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.600580 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.602530 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.603348 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.604369 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.605995 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.606812 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.608993 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.609717 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.610191 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.610643 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.611429 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.612155 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.612256 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.612761 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.613371 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.613694 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.614504 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.614521 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.615114 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.615743 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.616352 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.617564 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.617587 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.618213 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.619025 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.619306 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.619772 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.620565 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.621225 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.623367 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.625683 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.626055 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.628936 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.631589 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.638187 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.640686 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.641711 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.642319 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.642904 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.643495 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.643542 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.644455 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.645240 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.645880 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.646073 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.646520 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.647041 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.647205 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.648020 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.648200 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.648958 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.649067 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.649792 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.650056 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.650538 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.651121 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.651293 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.651876 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.655017 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.655118 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.656076 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.657117 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.657281 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.658138 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.659052 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.659642 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.660116 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.661209 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.662443 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.662553 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.663779 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.665382 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.665396 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.666980 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.670444 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.672208 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.676912 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.679990 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.680592 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.681143 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.681745 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.682106 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.682679 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.683272 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.683894 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.684365 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.687610 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.688589 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.689384 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.689998 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.690609 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.691311 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.691493 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.691979 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.692572 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.693178 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.693952 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.694700 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.695481 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.696268 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.705625 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.709592 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.712545 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.713157 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.713713 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.714600 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.714846 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.715422 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.716011 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.716582 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.717526 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.718512 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.719311 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.719931 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.720545 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.721208 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.721855 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.722456 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.723060 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.723864 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.724622 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.725406 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.726193 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.735507 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.744472 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.747292 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.747975 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.748771 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.749326 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.749889 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.750495 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.751088 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.751664 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.752265 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.752873 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.753557 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.754248 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.755145 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.755763 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.756381 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.756992 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.757581 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.758304 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.759049 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.759794 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.760440 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.761238 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.762227 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.762898 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.764893 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.767465 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.769580 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.769805 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.770675 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.771720 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.772671 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.773667 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.774703 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.775750 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.776860 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.777051 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.777965 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.777990 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.778665 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.779130 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.779483 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.780043 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.780318 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.780616 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.781226 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.781676 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.781844 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.782415 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.783143 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.783239 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.783972 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.784048 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.784613 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.784787 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.785475 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.786025 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.786393 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.787007 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.787516 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.787694 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.788309 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.788899 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.789345 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.789646 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.790381 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.790700 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.791281 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.791381 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.791952 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.792758 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.793728 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.794404 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.796118 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.796759 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.797367 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.799320 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.800634 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.801552 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.806122 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.808334 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.815045 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.821706 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.827788 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.828270 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.829003 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.830137 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.831304 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.831604 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.832462 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.832729 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.833487 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.833739 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.834309 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.834958 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.835282 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.836129 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.836442 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.837207 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.837735 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.837912 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.839205 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.839224 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.840091 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.840419 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.841067 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.841662 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.842866 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.843234 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.844057 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.844424 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.845902 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.847334 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.848824 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.850232 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.850698 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.851876 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.853381 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.856296 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.857975 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.859540 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.862222 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.863045 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.863577 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.864279 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.864398 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.865446 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.865458 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.865636 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.866544 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.866640 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.867452 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.867777 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.868531 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.868870 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.869206 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.869915 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.870300 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.870962 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.871186 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.871526 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.872004 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.872177 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.873033 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.874047 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.874344 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.875010 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.875223 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.876091 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.877188 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.878302 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.878621 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.879574 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.881023 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.881784 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.882628 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.885667 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.887918 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.892818 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.892921 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.893893 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.895060 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.895987 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.896924 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.897577 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.897846 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.898832 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.899976 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.900096 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.901023 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.901987 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.902996 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.903999 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.904928 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.905983 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.907075 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.907327 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.908204 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.909531 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.910977 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.912566 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.917808 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.922553 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.925596 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.927301 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.937013 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.955235 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.986079 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.987106 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.988177 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.989149 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.990163 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.991171 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.992228 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.993308 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.994420 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.995581 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.996403 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.996783 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.997469 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.998125 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.998577 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.999476 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105000.999746 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.001143 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.001157 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.002816 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.002825 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.004406 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.004518 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.006427 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.006440 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.008364 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.008478 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.010261 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.012418 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.013278 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.013918 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.015161 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.016200 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.017260 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.017833 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.018250 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.019243 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.019610 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.020272 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.021337 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.022409 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.023462 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.023571 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.024744 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.025954 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.027281 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.028632 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.030072 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.031477 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.032933 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.033072 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.034736 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.035938 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.036713 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.038763 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.041702 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.041702 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.044560 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.046238 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.046288 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.047698 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.047712 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.048865 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.050041 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.050630 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.051204 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.051815 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.052418 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.053890 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.053906 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.055075 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.056317 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.057019 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.057591 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.058792 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.059831 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.060057 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.061266 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.062813 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.063136 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.064317 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.065757 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.066086 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.067262 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.068831 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.069638 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.070485 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.071978 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.073519 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.074868 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.074914 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.076095 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.076622 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.077286 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.078492 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.078703 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.078813 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.079982 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.081190 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.082409 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.082869 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.083591 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.084448 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.084857 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.086117 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.087579 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.087601 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.088840 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.090050 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.090382 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.091621 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.093339 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.093445 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.094923 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.096432 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.097535 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.097875 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.099508 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.101004 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.103941 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.104637 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.105639 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.107199 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.111216 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.111795 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.113186 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.118949 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.119187 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.126347 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.129632 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.133463 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.140627 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.147876 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.147968 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.168242 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.187145 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.206669 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.215797 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.216835 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.217908 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.219058 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.220207 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.221652 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.223251 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.224923 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.226743 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.228634 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.230811 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.232309 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.238023 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.244470 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.245520 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.246599 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.247734 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.248878 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.249702 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.250322 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.251924 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.252576 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.253594 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.255519 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.255540 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.257419 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.258355 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.259584 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.261128 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.261306 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.264192 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.266801 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.267123 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.270156 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.273295 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.276102 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.278683 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.279307 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.281568 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.282266 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.284419 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.285913 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.287240 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.289883 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.290129 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.293027 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.293872 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.295972 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.298060 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.299055 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.302199 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.302618 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.305073 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.308389 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.308458 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.311356 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.314858 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.318844 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.322823 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.326386 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.327025 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.331604 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.337244 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.344897 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.355373 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.363046 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.373962 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.383544 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.392150 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.402482 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.412638 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.422070 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.431680 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.443249 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.446197 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.449162 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.451231 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.452208 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.455425 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.458584 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.462028 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.465472 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.469073 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.473002 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.477068 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.481143 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.485877 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.491189 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.496466 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.501721 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.508596 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.516068 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.525379 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.544137 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.570276 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.574024 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.577739 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.581435 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.584999 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.588542 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.592496 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.596168 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.600294 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.604400 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.608691 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.612672 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.618826 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.623913 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.627830 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.632804 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.638176 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.643242 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.649154 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.659955 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.661859 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.662925 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.665910 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.667215 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.668968 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.672197 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.673027 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.675389 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.678493 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.678863 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.682248 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.685811 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.688583 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.689841 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.691570 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.693985 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.694566 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.697617 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.698162 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.699799 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.700876 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.702917 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.704066 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.707534 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.708175 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.710930 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.713480 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.714400 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.718286 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.718759 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.721762 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.722521 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.725607 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.726810 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.731709 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.732998 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.737313 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.742276 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.742752 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.743680 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.748099 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.755047 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.761276 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.762577 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.765584 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.771922 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.786775 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.787814 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.791008 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.791620 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.795375 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.799104 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.802695 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.806271 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.808677 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.810301 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.814035 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.817551 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.818208 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.821346 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.822394 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.825080 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.826644 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.828799 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.830633 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.832389 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.835805 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.835985 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.839976 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.840872 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.843733 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.844779 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.847948 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.849757 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.852142 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.855172 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.856406 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.860346 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.860464 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.865551 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.866314 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.870610 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.874502 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.878654 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.879549 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.884006 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.885017 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.889806 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.890175 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.895275 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.896222 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.907231 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.912563 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.916674 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.918382 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.923828 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.938760 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.945145 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.960801 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.967051 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.982604 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105001.988938 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.003621 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.010809 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.025345 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.031968 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.054068 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.186963 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.190027 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.193441 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.197013 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.200676 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.205438 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.210748 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.216722 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.223248 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.230264 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.238409 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.243752 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.266961 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.289840 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.297731 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.303458 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.309333 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.315779 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.321795 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.327952 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.334610 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.340877 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.347830 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.353929 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.360137 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.368429 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.376675 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.384333 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.392830 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.402066 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.405718 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.408793 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.412241 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.413570 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.415866 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.419572 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.424369 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.429726 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.433156 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.435780 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.436236 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.439658 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.442403 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.443240 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.446957 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.448886 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.449502 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.451790 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.457102 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.457782 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.462877 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.463210 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.469428 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.476461 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.484827 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.484924 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.486671 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.490244 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.510496 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.513739 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.518204 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.520183 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.523954 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.529859 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.536321 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.537657 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.542355 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.544667 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.548534 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.550454 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.555289 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.556379 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.559298 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.561644 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.562595 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.568848 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.568928 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.575042 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.575775 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.581344 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.582166 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.588597 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.589666 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.595758 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.597971 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.599590 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.602043 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.605545 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.608439 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.614160 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.616985 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.623607 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.625484 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.633098 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.635219 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.637528 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.641780 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.651300 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.663126 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.670651 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.699307 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.706417 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.735219 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.742043 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.770349 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.781303 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.809305 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.821590 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.849716 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.860494 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105002.888282 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.108883 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.114824 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.120821 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.126952 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.133469 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.139891 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.147259 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.154538 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.162141 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.170498 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.179157 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.187764 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.197835 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.208848 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.219667 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.230392 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.244148 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.259039 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.276881 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.313772 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.336060 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.341996 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.348000 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.354136 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.360747 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.361292 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.364043 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.367327 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.367511 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.372308 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.373336 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.374714 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.379497 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.379742 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.382165 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.386069 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.387300 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.389793 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.392627 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.394960 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.398074 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.400127 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.402670 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.406677 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.407568 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.410363 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.415401 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.415484 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.418298 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.423890 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.425349 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.426602 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.432616 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.435384 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.436315 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.441213 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.443417 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.446919 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.451240 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.452065 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.457668 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.459138 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.462128 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.467752 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.471426 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.472819 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.475943 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.483139 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.483621 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.486338 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.491692 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.497437 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.501492 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.504305 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.512455 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.512562 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.523995 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.530567 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.534911 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.541054 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.545704 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.559535 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.567330 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.573285 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.584590 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.590957 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.596435 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.599572 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.607033 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.614443 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.617509 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.621944 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.626503 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.629697 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.634000 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.636446 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.637388 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.641554 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.645381 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.649280 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.653744 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.657130 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.662543 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.664988 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.670639 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.673070 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.679626 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.679657 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.681443 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.686810 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.690257 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.697717 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.698340 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.705954 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.707120 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.713166 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.714313 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.721788 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.722495 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.725174 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.731791 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.733385 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.740605 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.742814 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.749169 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.754290 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.758979 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.765248 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.765335 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.769841 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.775972 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.781398 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.789625 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.792351 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.803325 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.803344 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.808586 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.814576 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.817262 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.826434 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.831105 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.842453 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.854329 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.865424 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.866454 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.894114 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.909558 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.937050 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.952660 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.980205 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105003.995915 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.024222 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.039397 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.068652 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.097229 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.124661 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.620311 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.626392 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.633337 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.640441 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.647777 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.657844 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.669395 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.680261 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.692300 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.705087 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.719136 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.736664 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.756392 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.805102 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.857532 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.863635 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.870622 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.877941 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.880660 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.885546 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.886782 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.893748 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.895687 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.895707 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.900905 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.903791 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.907188 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.907411 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.908753 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.910804 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.914326 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.917686 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.918448 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.919051 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.921150 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.924882 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.928344 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.930383 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.931048 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.932224 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.936509 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.939940 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.942485 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.943578 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.943695 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.948230 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.952386 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.954489 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.957092 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.957869 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.962214 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.967545 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.975674 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.981401 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.981973 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.987591 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.995770 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105004.999980 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.006271 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.020272 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.024539 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.045229 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.052943 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.069708 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.077660 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.097644 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.136369 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.144976 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.148356 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.151982 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.155529 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.158917 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.162132 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.162401 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.166171 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.169656 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.171245 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.173563 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.174767 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.177891 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.178397 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.181374 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.182123 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.184903 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.185615 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.189608 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.189687 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.193280 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.193807 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.196882 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.198595 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.200888 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.203799 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.204403 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.208739 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.212269 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.216839 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.221035 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.223365 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.225844 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.229664 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.231106 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.248408 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.250932 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.257156 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.266729 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.275765 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.288042 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.293871 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.308970 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.315117 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.329450 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.333849 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.336018 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.337312 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.340727 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.344254 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.347946 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.351527 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.355507 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.356558 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.359598 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.363868 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.368414 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.373078 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.377742 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.383497 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.390296 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.396295 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.402440 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.410282 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.420036 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.429545 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.448648 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.478827 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.482886 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.486911 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.491364 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.495165 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.500189 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.505814 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.511444 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.517452 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.524177 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.530695 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.535837 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.543014 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.550245 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.557483 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.565476 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.567111 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.570571 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.571469 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.574011 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.576578 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.577562 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.581278 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.582550 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.584895 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.587712 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.588895 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.592769 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.594061 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.595660 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.596766 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.597559 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.600965 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.601378 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.604534 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.604794 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.606137 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.608296 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.610855 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.611970 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.613937 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.615991 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.616514 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.619939 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.623260 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.623837 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.624036 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.628404 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.629212 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.632008 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.633219 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.635388 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.638029 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.643111 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.643793 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.650652 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.652084 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.652796 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.656687 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.662251 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.662964 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.670945 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.672140 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.680738 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.681134 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.690384 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.693652 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.709901 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.710838 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.715042 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.715277 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.719142 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.723642 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.727485 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.732494 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.738103 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.740194 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.742881 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.743758 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.744342 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.748437 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.749800 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.752938 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.756582 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.757251 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.762430 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.763140 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.768025 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.768386 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.770698 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.773616 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.775635 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.779581 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.782927 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.786294 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.790230 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.792789 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.797962 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.798367 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.804422 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.805157 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.809626 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.812395 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.815682 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.819622 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.820914 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.827744 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.828970 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.833774 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.838200 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.838957 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.844970 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.847338 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.850144 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.857269 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.858231 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.865449 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.867503 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.876702 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.885607 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.886707 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.894878 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.905885 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.914940 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.927723 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.934986 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.949402 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.956612 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.977239 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105005.978220 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.004969 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.006012 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.034053 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.148151 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.151671 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.155446 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.159303 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.163475 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.168662 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.174289 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.180280 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.186861 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.196279 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.205364 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.216219 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.235534 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.276894 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.303876 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.343741 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.345722 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.347657 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.349708 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.351728 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.353835 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.355967 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.357858 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.359796 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.361734 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.364138 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.367258 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.369568 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.372068 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.375214 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.377793 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.380561 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.384080 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.385949 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.389483 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.393278 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.394244 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.397176 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.401346 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.403790 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.406673 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.412408 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.413109 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.413719 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.417255 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.418528 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.421082 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.424011 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.424983 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.425273 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.429145 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.434217 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.434569 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.434980 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.439957 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.444386 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.444900 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.446086 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.452737 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.455562 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.462334 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.471771 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.475299 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.482994 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.502783 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.517215 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.544569 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.544630 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.564927 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.567001 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.569010 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.571124 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.572379 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.573288 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.575531 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.577822 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.580156 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.582565 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.584979 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.585073 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.586968 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.587607 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.588915 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.590931 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.591029 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.593071 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.593994 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.595195 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.597458 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.597557 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.599371 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.601151 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.601345 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.603289 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.605249 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.605793 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.608966 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.610055 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.611330 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.613877 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.616090 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.617072 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.618179 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.619850 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.619858 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.620143 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.622186 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.622673 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.624232 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.626306 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.626524 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.628693 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.630634 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.632539 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.634495 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.636628 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.636911 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.637277 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.639696 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.640066 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.642518 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.642736 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.644915 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.645122 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.646362 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.647285 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.648309 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.650022 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.650918 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.652469 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.653726 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.654918 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.655886 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.657268 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.657545 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.661109 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.664664 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.666973 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.667658 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.667879 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.671797 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.675248 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.677426 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.677674 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.679206 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.681991 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.686104 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.686978 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.688112 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.689656 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.693975 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.698054 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.698314 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.703264 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.708772 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.710149 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.719256 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.720358 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.731332 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.742313 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.753293 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.764319 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.778420 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.792564 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.809119 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.811194 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.813196 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.815308 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.817480 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.819736 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.822028 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.824332 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.826772 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.829340 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.831877 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.835009 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.837993 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.839821 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.841250 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.841923 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.843921 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.844807 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.846056 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.848216 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.848889 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.850490 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.852785 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.853696 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.855106 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.857519 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.860017 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.862588 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.863326 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.865768 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.868807 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.872065 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.875634 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.879761 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.880845 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.883302 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.884630 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.886091 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.888435 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.890787 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.893537 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.894477 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.895997 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.898444 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.901075 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.904671 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.908287 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.911514 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.912080 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.914520 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.915495 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.917313 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.918974 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.919705 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.922054 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.922964 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.924803 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.925785 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.927259 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.929701 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.929951 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.932334 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.933542 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.935929 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.937927 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.939556 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.942314 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.942781 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.946740 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.947337 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.950216 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.954336 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.954418 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.957171 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.961344 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.964822 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.964978 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.969342 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.973709 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.975899 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.978705 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.982594 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.984869 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.985645 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.986934 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.987182 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.989851 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.992688 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.995716 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.995995 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.997972 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105006.998947 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.002396 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.006768 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.007026 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.009006 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.011662 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.017781 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.018127 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.023168 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.028483 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.029126 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.037288 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.040103 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.040683 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.054279 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.057529 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.068486 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.079313 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.105154 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.106415 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.107620 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.108883 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.110187 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.111539 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.112752 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.113938 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.115273 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.116492 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.117906 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.119272 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.121023 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.122477 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.124236 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.125756 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.127357 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.129344 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.134791 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.139537 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.144246 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.150025 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.155812 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.215869 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.217213 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.218509 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.219824 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.221186 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.222589 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.224014 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.225474 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.226982 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.227746 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.228509 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.230167 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.230293 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.232023 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.232642 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.233877 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.235342 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.235850 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.237938 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.238223 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.240355 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.241307 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.242870 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.244565 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.247640 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.248056 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.252526 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.253358 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.257480 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.259081 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.261400 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.263769 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.263847 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.266548 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.266568 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.268039 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.269522 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.269621 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.271157 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.272752 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.272764 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.274617 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.274652 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.275997 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.276348 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.278072 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.279456 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.279670 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.281339 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.283142 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.283837 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.285136 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.286677 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.286941 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.288835 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.289133 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.290992 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.292848 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.295193 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.295294 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.297040 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.299302 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.301516 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.303631 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.304069 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.306033 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.307151 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.311152 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.314527 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.318055 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.320156 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.325502 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.325779 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.331390 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.335034 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.336953 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.344031 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.351119 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.352697 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.353972 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.355190 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.356460 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.356761 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.357782 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.359157 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.359524 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.360412 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.361611 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.362956 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.364202 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.365632 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.367013 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.368794 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.370269 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.372050 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.373585 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.375217 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.377233 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.382725 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.383392 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.384663 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.385878 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.387143 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.387503 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.388456 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.389812 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.391035 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.392373 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.392453 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.393733 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.394967 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.396378 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.397742 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.398318 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.399508 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.400960 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.402720 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.404301 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.404372 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.405990 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.407991 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.413461 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.418187 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.423070 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.428877 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.434671 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.454615 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.456218 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.457791 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.459518 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.461342 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.463275 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.465320 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.465362 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.466690 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.467487 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.467995 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.469311 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.470674 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.472083 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.473522 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.475002 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.476516 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.478041 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.479577 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.479865 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.481446 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.483052 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.483343 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.485320 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.487107 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.487437 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.489859 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.491724 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.492393 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.494756 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.496099 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.497303 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.497480 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.497704 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.498806 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.500171 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.501579 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.503140 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.503228 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.504624 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.506319 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.506344 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.507843 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.509358 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.511210 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.513057 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.515011 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.515590 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.516569 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.517218 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.517299 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.518603 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.519768 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.520252 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.521783 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.522273 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.523468 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.525219 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.527090 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.527235 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.528759 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.530457 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.532268 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.533035 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.534279 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.536101 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.538287 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.540149 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.541303 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.542083 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.542297 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.543379 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.544585 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.544689 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.545347 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.545701 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.546450 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.546923 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.547032 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.547873 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.548401 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.548741 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.549006 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.549978 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.550149 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.551113 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.551216 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.551682 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.552394 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.553360 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.553852 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.553867 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.555203 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.555219 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.556719 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.557063 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.557081 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.558140 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.558680 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.559802 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.560358 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.561036 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.562180 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.562928 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.564204 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.564432 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.564762 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.566041 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.566437 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.568216 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.568886 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.570159 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.570260 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.571325 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.572019 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.574465 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.574562 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.575961 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.576320 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.577483 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.578583 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.580790 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.581636 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.583342 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.586379 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.587307 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.590255 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.593580 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.594535 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.599208 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.601786 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.604820 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.607355 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.608301 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.609262 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.610203 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.610513 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.610580 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.611174 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.612298 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.613469 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.614617 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.615800 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.616180 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.617039 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.618252 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.619551 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.620753 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.622169 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.623324 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.623638 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.625075 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.627046 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.628400 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.630462 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.630887 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.633888 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.638933 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.642353 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.643726 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.645037 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.646430 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.647785 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.649104 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.650405 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.651560 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.652715 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.653906 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.655298 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.656733 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.658141 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.659586 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.660854 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.662384 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.664240 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.666097 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.668539 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.670564 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.672588 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.674737 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.677658 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.680578 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.683494 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.686405 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.690062 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.693730 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.698430 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.702744 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.706464 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.708085 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.709664 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.711396 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.713232 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.715160 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.717126 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.719246 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.731685 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.735105 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.735138 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.736764 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.738335 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.739317 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.740072 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.741904 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.743836 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.744116 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.745800 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.747915 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.750307 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.750889 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.751864 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.752970 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.754141 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.755466 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.756664 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.757667 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.758843 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.759066 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.760327 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.763508 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.765841 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.767543 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.768941 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.769502 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.772263 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.772648 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.777171 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.778343 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.781063 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.787045 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.792108 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.792817 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.793544 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.794203 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.794564 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.794937 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.795667 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.795774 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.796511 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.796772 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.797174 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.797428 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.798114 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.798123 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.798953 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.799257 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.799681 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.800366 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.800632 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.801318 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.801689 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.802458 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.803510 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.803611 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.804888 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.804908 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.806117 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.806286 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.807357 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.807640 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.808641 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.809010 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.810166 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.810478 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.811606 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.811862 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.813295 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.814316 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.816451 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.816949 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.818303 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.819982 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.822505 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.822663 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.822685 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.823623 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.824716 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.824980 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.825813 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.826926 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.828147 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.828165 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.829108 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.830254 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.831267 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.831433 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.832391 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.833560 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.834787 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.836060 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.837486 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.837792 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.838486 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.839121 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.839233 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.839909 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.840592 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.840819 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.841400 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.842248 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.843073 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.844016 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.844120 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.844849 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.845696 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.845974 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.846561 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.847476 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.847677 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.848433 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.849268 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.850300 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.850405 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.852501 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.852781 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.854662 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.855818 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.858879 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.861396 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.861877 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.862346 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.863029 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.863322 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.864057 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.864260 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.865217 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.865313 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.866434 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.866526 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.867633 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.867734 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.868673 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.868890 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.869721 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.870083 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.870805 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.871326 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.871904 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.872649 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.872749 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.873558 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.873961 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.874379 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.875161 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.875502 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.876573 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.876674 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.878317 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.878442 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.879927 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.880681 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.881921 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.882671 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.883310 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.884644 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.885820 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.886939 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.888228 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.888971 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.889247 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.890220 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.891170 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.891268 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.892200 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.893299 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.894045 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.894446 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.895620 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.896801 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.896967 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.898014 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.899265 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.899280 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.899927 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.900545 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.900720 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.901906 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.902085 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.903122 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.903520 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.904561 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.904878 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.906094 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.906253 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.907694 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.907764 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.908930 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.909705 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.910108 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.911103 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.911316 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.912713 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.913628 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.914178 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.915582 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.916677 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.917048 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.918315 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.919855 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.921735 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.923599 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.924418 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.925216 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.926197 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.926207 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.926739 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.927096 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.927981 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.928197 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.928301 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.928884 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.929520 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.930083 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.930351 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.930909 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.931179 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.932402 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.932572 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.932687 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.933907 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.934227 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.935224 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.935647 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.936391 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.937546 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.938584 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.938737 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.938842 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.940241 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.941414 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.941778 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.941795 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.943204 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.944291 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.944781 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.944853 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.946062 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.947304 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.947610 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.948543 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.949470 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.951022 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.951332 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.952233 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.953667 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.955699 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.956946 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.957728 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.959888 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.961309 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.962846 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.963340 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.964020 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.965033 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.965782 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.966613 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.967786 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.968722 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.969192 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.970215 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.971258 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.971666 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.972459 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.973879 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.975352 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.975677 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.977020 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.979025 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.982338 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.983649 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.984549 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.988003 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105007.990722 2785003 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.009569 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.010543 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.011651 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.012826 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.014155 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.015355 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.016361 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.017533 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.024543 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.027668 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.031397 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.036057 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.036427 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.037400 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.038503 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.039681 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.039985 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.041021 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.042212 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.043201 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.044372 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.051346 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.051355 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.052047 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.052772 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.053425 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.054156 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.054458 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.054910 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.055641 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.056292 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.057062 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.057888 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.058152 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.058613 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.059551 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.060593 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.062473 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.062693 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.063522 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.064896 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.066255 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.066569 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.067648 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.069097 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.070483 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.072940 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.075585 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.077799 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.078504 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.079229 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.079879 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.080602 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.080834 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.081377 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.082104 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.082862 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.083512 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.084335 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.085052 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.085985 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.087030 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.088898 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.089931 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.091295 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.092638 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.094008 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.095456 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.096081 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.096916 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.096986 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.097602 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.098295 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.098978 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.099462 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.099784 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.100629 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.101451 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.102160 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.102485 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.103307 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.104153 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.105003 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.105903 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.106844 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.107448 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.107707 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.108748 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.110867 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.112964 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.120249 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.121394 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.122463 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.122628 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.123353 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.123533 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.124033 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.124681 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.124794 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.125486 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.125772 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.126292 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.126816 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.127159 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.127912 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.128073 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.128925 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.129097 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.129779 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.130204 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.130633 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.131018 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.131499 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.131836 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.132403 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.132651 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.133356 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.133779 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.134205 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.134747 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.135265 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.135764 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.137392 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.138090 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.139563 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.140078 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.142048 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.144348 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.145629 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.146953 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.148103 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.148522 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.149123 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.150148 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.151212 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.151427 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.152309 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.153339 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.154453 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.154527 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.155607 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.156683 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.157419 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.157575 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.158386 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.159185 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.160298 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.162205 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.163220 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.165491 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.167470 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.169429 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.171714 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.172988 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.175855 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.178728 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.181604 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.182168 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.182964 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.183707 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.184648 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.184716 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.185572 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.186449 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.187365 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.188435 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.189509 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.191333 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.195572 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.198363 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.201245 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.204281 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.208007 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.209280 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.210064 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.210814 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.211704 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.212667 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.213547 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.214463 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.215531 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.218216 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.218804 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.219489 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.220042 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.220511 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.222078 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.223253 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.224280 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.224581 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 2/30\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m3s\u001b[0m 140ms/step - loss: 0.0793 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1727105008.225599 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.226646 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.227130 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.227852 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.229274 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.230013 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.231091 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.232441 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.237005 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.237759 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.239946 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.240736 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.246047 2784936 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.251353 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.252025 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.253043 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.254616 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.255779 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.257141 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.258157 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.259198 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.260381 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.261778 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.263569 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.264909 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.270184 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.272334 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105008.278436 2785006 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 121ms/step - loss: 0.0566" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:23:31.688078: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-09-23 15:23:31.688216: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-09-23 15:23:31.688342: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1727105012.655198 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.655224 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.655407 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.656257 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.656270 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.656395 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.657223 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.657362 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.657448 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.658347 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.658396 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.658529 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.659395 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.659430 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.659546 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.660442 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.660590 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.660675 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.661332 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.661566 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.661821 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.662319 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.662551 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.662785 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.663198 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.663442 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.663650 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.664199 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.664471 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.664654 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.669780 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.669972 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.669994 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.670826 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.671107 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.671126 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.671630 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.671980 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.672090 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.672414 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.672827 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.673017 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.673425 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.673878 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.674079 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.674554 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.675014 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.675314 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.675854 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.676299 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.676634 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.677211 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.677603 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.677968 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.678473 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.678862 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.679240 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.679756 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.680162 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.680547 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.681155 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.681583 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.681965 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.682532 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.682946 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.683351 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.685552 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.685714 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.686428 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.686596 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.686629 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.686965 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.687526 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.687638 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.687760 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.688490 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.688777 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.688869 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.689705 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.690147 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.690258 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.691441 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.692065 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.692151 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.692460 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.693240 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.693323 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.693692 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.694640 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.694720 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.694955 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.696385 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.696424 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.696535 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.697495 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.697753 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.697917 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.698976 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.699254 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.700987 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.702122 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.702372 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.703849 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.704971 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.705215 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.705539 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.706647 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.706901 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.707781 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.708828 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.709042 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.729443 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.729481 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.730095 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.730357 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.730439 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.730962 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.731175 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.731254 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.731575 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.731952 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.732033 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.732271 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.732742 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.732879 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.733055 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.733374 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.733603 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.733769 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.734037 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.734320 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.734503 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.736113 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.736391 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.736598 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.738927 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.739210 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.739419 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.742618 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.742955 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.743166 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.746347 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.746728 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.746952 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.749327 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.749704 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.749942 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.752819 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.753233 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.753467 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.756224 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.756666 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.756906 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.824290 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.825101 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.825249 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.825389 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.825944 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.825980 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.826097 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.826860 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.826871 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.826981 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.827696 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.827762 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.827865 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.828531 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.828675 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.828773 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.829406 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.829566 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.829673 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.830232 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.830553 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.830655 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.831018 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.831330 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.831504 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.831797 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.832132 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.832303 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.832584 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.832955 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.833125 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.833386 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.833986 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.834122 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.834331 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.834941 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.835174 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.835352 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.836159 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.836288 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.836487 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.837109 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.837542 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.837614 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.838117 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.838569 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.838754 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.839124 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.839657 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.839839 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.840828 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.840950 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.841559 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.842560 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.842660 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.843075 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.844190 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.845371 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.845868 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.847003 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.847376 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.847876 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.849024 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.855839 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.856592 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.857293 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.857579 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.858086 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.858348 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.858801 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.859079 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.859323 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.859618 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.859895 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.860350 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.860442 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.860723 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.861232 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.861441 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.861544 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.862229 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.862471 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.862560 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.862957 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.863526 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.863755 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.863870 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.864341 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.864712 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.864797 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.865631 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.865719 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.865918 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.866574 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.866745 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.867765 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.867939 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.868778 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.869399 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.869889 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.871456 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.872986 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.873382 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.875073 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.876449 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.877003 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.878554 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.880505 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.883545 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.885701 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.887684 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.890623 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.892815 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.894819 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.895012 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.897216 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.899258 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.899458 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.901669 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105012.903746 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.034797 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.035601 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.036429 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.037470 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.037606 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.038510 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.038620 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.039539 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.039712 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.039966 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.040453 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.040686 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.040875 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.041459 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.041749 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.041829 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.042621 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.042850 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.042875 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.044044 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.044070 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.044100 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.045220 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.045316 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.045428 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.046111 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.046478 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.046597 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.047101 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.047565 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.047820 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.048112 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.048719 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.049430 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.049435 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.049847 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.050595 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.050940 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.051131 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.051711 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.052637 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.052788 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.052979 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.054499 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.054694 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.054815 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.056045 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.056567 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.056580 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.057719 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.058138 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.059289 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.059458 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.059826 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.061516 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.062138 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.062929 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.064190 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.065804 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.066792 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.067859 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.069683 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.071750 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.077403 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.078531 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.079616 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.080371 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.080873 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.081521 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.082066 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.082444 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.082645 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.083487 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.083610 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.083934 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.084684 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.084801 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.085260 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.085760 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.086090 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.086456 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.087008 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.087280 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.087552 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.088873 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.088906 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.089034 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.089988 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.090205 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.090681 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.091054 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.092136 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.092466 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.092568 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.093908 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.094392 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.095842 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.096039 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.097894 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.098322 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.101568 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.103657 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.105160 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.108461 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.110556 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.111766 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.115132 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.117251 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.125635 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.129038 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.131259 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.133895 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.139605 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.142896 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.147787 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.151168 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.153530 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.156234 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.159553 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.161971 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.426866 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.428093 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.429289 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.430071 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.430540 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.431417 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.431809 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.432655 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.433156 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.433591 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.433950 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.434496 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.434915 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.435262 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.435877 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.436146 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.436626 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.437679 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.437674 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.437991 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.438990 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.439473 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.439585 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.440361 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.441236 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.441343 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.441716 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.443052 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.443274 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.443320 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.445190 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.445233 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.445316 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.447087 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.447345 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.447426 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.448717 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.449193 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.449718 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.450392 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.451309 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.452203 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.453624 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.454339 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.456629 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.457063 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.459439 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.461019 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.462056 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.463431 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.464032 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.464862 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.466059 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.466482 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.468882 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.469135 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.469896 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.471976 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.473996 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.477072 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.483738 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.485486 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.487211 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.489113 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.490757 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.491613 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.492447 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.493103 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.493419 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.494532 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.494871 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.495212 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.496864 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.497011 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.497170 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.499184 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.499222 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.499302 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.501255 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.501283 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.501311 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.503131 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.503281 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.503458 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.505498 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.505546 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.505735 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.507834 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.507868 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.509605 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.509818 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.511671 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.511742 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.513635 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.514261 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.515667 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.516165 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.524911 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.526271 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.526799 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.535699 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.537180 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.540552 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.549509 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.551099 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.553738 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.562789 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.564517 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.567838 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.577027 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.578840 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.582214 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.591637 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.594008 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.611983 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.623004 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105013.623936 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.154019 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.155973 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.158016 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.159929 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.161963 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.164132 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.165837 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.166413 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.167575 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.167818 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.168644 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.169546 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.169911 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.171302 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.171622 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.171871 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.173563 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.173919 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.174403 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.175620 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.176097 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.177132 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.177805 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.178407 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.180064 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.180173 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.180651 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.182415 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.182859 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.183241 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.185019 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.186329 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.186625 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.188100 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.189063 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.190966 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.191064 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.191866 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.193913 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.194661 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.195398 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.196721 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.198376 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.200448 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.202637 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.204634 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.207207 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.208676 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.209155 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.213541 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.218855 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.220748 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.222633 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.225716 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.227600 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.228760 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.231167 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.233039 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.241337 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.243132 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.251157 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.254204 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.257759 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.260965 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.262096 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.263852 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.264052 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.265211 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.266944 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.267861 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.268749 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.270466 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.270902 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.271999 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.273691 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.274863 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.275138 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.276797 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.277810 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.278985 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.280755 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.280852 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.282121 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.283811 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.284335 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.286230 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.287900 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.288107 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.289289 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.290958 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.292389 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.294057 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.296000 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.297671 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.299756 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.301422 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.307532 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.320034 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.321303 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.328753 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.342015 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.342990 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.355625 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.369127 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.370171 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.381354 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.394854 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.396208 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.409005 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.422379 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.423947 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.439377 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.453297 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.455142 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.500158 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.515527 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105014.517828 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.577564 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.580855 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.584161 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.587476 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.591052 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.594740 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.597435 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.598767 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.600777 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.602479 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.604240 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.604523 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.606984 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.607683 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.607901 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.610885 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.611403 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.611467 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.614786 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.615220 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.615646 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.618399 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.619225 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.620770 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.622121 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.622945 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.626269 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.626370 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.627448 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.629990 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.631501 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.633778 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.634541 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.636526 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.638698 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.641250 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.641615 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.643751 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.647025 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.649100 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.649108 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.654546 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.654674 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.662324 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.662357 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.669936 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.670120 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.672617 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.677639 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.681951 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.693925 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.697545 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.701457 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.702998 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.703356 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.708523 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.710936 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.715655 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.719109 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.721554 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.724744 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.726914 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.727351 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.730453 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.732553 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.734087 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.737937 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.738285 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.739775 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.743899 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.745663 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.747758 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.749696 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.751582 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.753591 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.756793 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.757457 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.760496 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.762610 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.764384 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.767760 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.770061 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.770683 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.776705 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.777993 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.784135 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.784162 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.791073 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.791559 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.798403 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.806476 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.831173 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.836795 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.848424 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.873323 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.878652 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.900720 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.926126 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.931587 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.951195 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.976749 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105015.982648 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.003509 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.030155 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.035585 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.063616 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.091043 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.097481 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.185681 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.210004 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105016.219001 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.336901 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.342824 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.348823 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.354915 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.361581 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.362983 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.368428 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.368987 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.375066 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.375934 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.381294 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.383443 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.388172 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.389295 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.392649 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.395305 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.395507 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.400566 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.401352 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.403516 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.407486 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.410365 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.411241 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.414145 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.420330 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.420722 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.421387 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.428918 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.429316 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.430925 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.436879 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.438994 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.445827 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.446161 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.449215 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.454222 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.459992 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.460292 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.464135 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.474212 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.475249 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.475506 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.484796 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.489754 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.499750 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.504868 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.514597 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.519337 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.529834 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.536967 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.549517 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.562894 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.567504 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.568394 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.571347 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.574084 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.574288 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.577229 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.581130 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.584618 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.587534 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.591656 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.591904 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.594610 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.595868 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.598114 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.600189 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.601809 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.603209 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.606154 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.609206 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.613181 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.616733 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.619694 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.619972 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.623789 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.624071 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.624334 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.626809 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.627340 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.630516 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.630602 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.633533 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.634354 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.637472 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.640978 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.642642 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.643913 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.647967 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.650913 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.654424 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.656812 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.658134 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.669637 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.675248 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.680426 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.695296 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.698772 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.702248 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.720991 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.725654 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.728002 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.749787 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.751257 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.754787 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.776993 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.783429 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.805433 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.811068 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.845237 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105018.866367 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.842186 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.845338 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.848249 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.851326 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.854606 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.857860 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.861321 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.864588 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.868249 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.872041 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.876644 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.881263 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.883188 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.886561 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.886588 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.889547 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.892684 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.893474 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.896015 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.899338 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.901097 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.902833 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.906259 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.906453 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.908052 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.909609 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.909952 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.912548 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.913614 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.915668 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.918187 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.918975 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.922251 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.922958 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.925748 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.926793 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.928251 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.929066 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.932722 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.935211 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.935634 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.936352 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.940666 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.942920 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.945429 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.950020 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.950677 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.953278 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.954243 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.955215 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.956228 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.957224 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.957604 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.958518 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.959797 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.965279 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.966533 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.969151 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.971942 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.972351 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.978330 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.979113 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.985874 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.991314 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.992621 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.994011 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.994999 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.995988 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.997030 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.998068 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.999594 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105019.999620 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.000338 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.000926 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.007876 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.012680 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.013554 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.016151 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.017136 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.018119 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.019141 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.020156 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.020974 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.021474 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.022761 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.027961 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.029567 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.035029 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.035201 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.042146 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.042568 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.049388 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.055634 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.056250 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.063216 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.076563 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.252784 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.253701 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.254678 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.255602 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.256552 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.257563 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.258576 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.259643 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.260637 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.261654 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.262772 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.263856 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.265137 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.266398 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.267764 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.269482 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.271426 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.273198 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.290061 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.294526 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.295130 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.295463 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.296469 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.297553 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.297656 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.298619 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.299638 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.300673 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.301758 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.302775 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.303797 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.304899 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.305992 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.307262 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.307435 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.308066 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.308664 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.308791 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.309425 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.310050 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.310317 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.311807 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.313529 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.313769 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.315533 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.316741 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.317075 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.318000 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.318972 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.320133 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.320146 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.321102 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.322117 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.323134 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.323776 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.324216 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.325210 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.326224 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.327464 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.327560 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.328565 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.329836 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.331087 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.331680 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.332651 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.332744 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.334414 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.336405 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.336575 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.337873 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.338207 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.340186 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.350070 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.350688 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.351264 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.351900 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.352788 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.355262 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.355965 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.359172 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.360379 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.362375 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.362678 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.365852 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.366075 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.366407 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.366968 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.367539 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.368127 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.368784 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.369365 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.369701 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.370027 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.370635 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.371236 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.371913 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.372599 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.372776 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.373470 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.373588 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.373849 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.374233 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.374345 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.374946 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.375067 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.375567 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.375960 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.378273 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.378762 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.379294 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.379391 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.380606 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.381706 2784922 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.382630 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.385799 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.389453 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.393072 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.397256 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.402164 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.408330 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.408868 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.409429 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.409968 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.410552 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.411206 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.411791 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.412440 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.413053 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.413649 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.414335 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.415026 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.415739 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.416310 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.416898 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.417499 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.420197 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.421059 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.422344 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.423440 2784962 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.431784 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.432503 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.433084 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.433646 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.434232 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.434886 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.435461 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.436106 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.436700 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.437294 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.437975 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.438666 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.439378 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.439948 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.440544 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.441144 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.443842 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.444695 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.445983 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.447087 2785000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "2024-09-23 15:23:40.714108: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1727105020.726290 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.726863 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.726859 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.727497 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.727604 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.728308 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.728322 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.729090 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.729103 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.729775 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.729882 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.730024 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.730688 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.730701 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.730806 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.731578 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.731604 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.731631 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.732461 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.732561 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.732639 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.733351 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.733488 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.733509 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.733885 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.734183 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.734361 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.734479 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.734772 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.735195 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.735206 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.735405 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.735945 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.735968 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.736086 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.736557 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.736793 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.736941 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.737111 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.737541 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.737681 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.737859 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.738367 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.738445 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.738559 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.738826 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.739530 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.739573 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.739643 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.740610 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.740629 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.740660 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.741479 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.741736 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.741753 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.742173 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.742771 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.742815 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.742996 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.743990 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.744000 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.744105 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.744962 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.745043 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.745476 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.745952 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.746168 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.746575 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.746682 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.747521 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.747540 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.747542 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.748000 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.748261 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.748584 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.749136 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.749565 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.749580 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.749793 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.750244 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.750372 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.750628 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.751054 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.751215 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.751378 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.751841 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.752143 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.752256 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.752541 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.753024 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.753483 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.753485 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.753717 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.754186 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.754596 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.754983 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.755160 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.755765 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.756354 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.756568 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.756903 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.758122 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.758157 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.758344 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.759415 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.759438 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.759477 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.760494 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.760776 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.761123 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.761803 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.762675 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.763623 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.764641 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.765961 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.771120 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.771574 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.771988 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.772006 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.772613 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.772723 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.773337 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.773353 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.774052 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.774066 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.774769 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.774783 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.775210 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.775656 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.776037 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.776321 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.776818 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.776994 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.777264 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.777835 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.777917 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.778290 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.778858 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.778926 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.779379 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.779917 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.780641 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.780895 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.781960 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.782351 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.782964 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.783672 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.784338 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.784667 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.785571 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.786351 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.786588 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.787426 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.788043 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.788465 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.789925 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.791754 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.821874 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.822305 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.822751 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.823203 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.823718 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.823815 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.824281 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.824401 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.824761 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.824962 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.825237 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.825501 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.825819 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.825996 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.826119 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.826304 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.826630 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.826835 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.826928 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.827299 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.827521 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.827591 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.827837 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.828186 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.828292 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.828480 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.828691 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.828996 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.829146 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.829311 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.829814 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.829977 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.829994 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.830651 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.830753 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.830834 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.831501 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.831612 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.831711 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.832029 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.832365 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.832502 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.832680 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.833169 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.833447 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.833514 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.833826 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.834121 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.834523 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.834670 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.834784 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.835422 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.835695 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.836087 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.836266 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.836598 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.837080 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.837422 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.837850 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.838330 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.838808 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.839498 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.840527 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.841661 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.844755 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.845277 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.845749 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.846267 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.846731 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.846822 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.847431 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.847526 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.848044 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.848144 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.848491 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.848845 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.848879 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.849079 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.849532 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.849661 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.849681 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.850534 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.850603 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.850626 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.851055 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.851298 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.851406 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.851595 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.852171 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.852179 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.852271 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.852656 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.852942 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.853186 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.853588 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.853757 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.854367 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.854470 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.854548 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.855156 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.855835 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.856287 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.856536 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.857909 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.858142 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.858460 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.859828 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.860315 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.861704 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.861873 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.864017 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.865341 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.865581 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.867776 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.867971 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.869004 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.870183 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.870401 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.871383 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.872625 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.873791 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.938510 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.939057 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.939592 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.940134 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.940690 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.940929 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.941382 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.941485 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.941574 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.942051 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.942181 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.942184 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.942781 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.942884 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.942893 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.943537 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.943610 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.943618 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.944398 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.944407 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.944421 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.945146 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.945149 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.945258 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.945915 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.945929 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.946023 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.946719 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.946724 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.946843 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.947439 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.947534 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.947710 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.948112 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.948280 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.948565 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.948825 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.948999 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.949635 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.949660 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.949788 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.950394 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.950713 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.950787 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.951212 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.951735 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.951813 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.952066 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.952615 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.952953 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.953264 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.953580 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.953912 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.954537 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.954875 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.955227 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.955746 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.956329 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.957295 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.957382 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.958289 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.959229 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.960352 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.961270 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.966153 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.966849 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.967516 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.968264 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.968515 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.969058 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.969233 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.969582 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.969746 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.969921 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.970281 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.970467 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.970675 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.971028 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.971198 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.971447 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.971788 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.971972 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.972163 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.972494 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.972893 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.973088 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.973259 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.973539 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.974070 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.974076 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.974269 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.974875 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.975121 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.975322 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.975650 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.976269 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.976446 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.977425 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.977518 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.978564 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.978642 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.979562 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.980492 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.980808 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.981415 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.982102 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.982574 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.983823 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.984373 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.985137 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.985539 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.986557 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.987832 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.988359 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.989992 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.990063 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.992227 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.993338 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.995996 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.997167 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105020.999374 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.000432 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.003898 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.004383 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.006628 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.008746 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.011062 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.013078 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.014089 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.015079 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.016155 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.017110 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.018292 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.019258 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.020440 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.021512 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.022468 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.023559 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.024688 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.030767 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.036085 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.042879 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.049607 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.056737 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.063952 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.078361 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.144397 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.145190 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.145938 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.146641 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.147399 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.147725 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.148193 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.148457 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.148980 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.149195 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.149790 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.149956 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.150797 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.150865 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.151684 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.151861 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.152475 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.152796 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.153260 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.153755 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.154168 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.154682 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.155193 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.155859 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.156121 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.157184 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.157256 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.158115 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.158584 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.159297 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.160014 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.160572 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.161546 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.161903 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.163330 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.164194 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.164859 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.167526 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.168642 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.172032 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.172213 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.175582 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.184860 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.185944 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.186942 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.187355 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.188038 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.188414 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.189000 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.189427 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.190212 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.190529 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.191202 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.191495 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.192394 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.192701 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.193529 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.193724 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.194521 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.194916 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.195622 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.196007 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.196754 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.196984 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.198069 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.199184 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.202841 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.205323 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.208174 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.210716 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.214995 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.217617 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.221629 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.224651 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.228855 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.232022 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.236192 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.239427 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.250835 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.253481 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.347687 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.348897 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.350069 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.351160 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.352332 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.353615 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.354830 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.356079 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.357527 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.359201 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.360690 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.362230 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.363748 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.365722 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.367905 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.370167 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.372634 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.375771 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.378482 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.383455 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.391421 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.406515 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.408216 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.409948 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.411801 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.413476 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.415474 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.417091 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.419171 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.420768 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.422376 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.424238 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.426179 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.437353 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.447937 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.461622 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.474802 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.488664 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.503268 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.524164 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.525319 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.526462 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.527328 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.527541 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.528476 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.528719 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.529649 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.530002 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.530740 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.531231 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.531921 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.532483 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.533133 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.533297 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.533932 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.534529 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.535784 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.535875 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.537515 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.537603 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.539387 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.539401 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.541165 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.541179 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.542736 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.543173 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.544275 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.545385 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.546285 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.547707 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.548516 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.550212 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.550866 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.552956 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.553393 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.556134 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.557897 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.561111 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.565876 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.569131 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.580195 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.581877 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.582781 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.583609 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.584491 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.585464 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.586246 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.587134 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.588134 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.589143 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.589823 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.590764 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.591853 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.592849 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.593502 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.594452 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.595616 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.596054 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.597237 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.597921 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.598859 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.599853 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.600736 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.602664 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.611078 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.613883 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.621444 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.624585 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.634847 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.638367 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.647851 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.651649 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.661831 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.665794 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.676301 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.680294 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.706131 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105021.709734 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.072568 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.074398 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.076206 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.078015 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.079931 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.081921 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.083879 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.085981 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.088125 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.090495 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.092977 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.095539 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.098256 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.101984 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.105670 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.109482 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.114203 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.119742 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.124805 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.145152 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.148085 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.151027 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.154762 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.157797 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.160761 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.163578 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.166953 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.170794 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.173643 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.177172 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.180887 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.203673 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.225365 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.249560 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.251381 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.252357 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.253179 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.254976 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.256902 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.257560 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.258893 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.259392 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.260881 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.261231 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.263239 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.263246 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.265220 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.265432 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.267225 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.267834 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.269226 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.270351 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.271347 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.272900 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.273527 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.275576 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.275940 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.278487 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.278471 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.279290 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.281071 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.282913 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.283811 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.286706 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.287613 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.291435 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.291556 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.295294 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.296614 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.300046 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.304035 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.305132 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.316664 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.319806 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.322671 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.325392 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.326304 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.328310 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.329344 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.331215 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.331807 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.332265 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.335059 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.335162 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.338121 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.338469 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.341063 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.342239 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.343863 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.345040 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.347228 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.348548 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.351086 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.352214 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.353931 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.357279 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.360839 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.374662 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.383714 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.394438 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.396113 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.405586 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.423067 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.432973 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.448762 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.459001 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.474338 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.484550 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.502250 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.513264 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.564775 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105022.577754 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.469459 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.472643 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.475837 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.479046 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.482438 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.485986 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.489474 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.493237 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.497030 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.501314 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.506349 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.511478 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.516885 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.524328 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.531985 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.539873 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.549316 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.560242 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.570316 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.604541 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.606182 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.607804 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.609414 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.611000 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.613021 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.614846 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.616388 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.618495 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.620054 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.621892 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.623804 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.634815 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.646481 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.648933 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.649638 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.652786 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.655979 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.659368 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.662555 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.662913 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.666398 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.668738 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.670167 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.671894 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.673643 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.674023 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.675072 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.678289 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.678636 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.681710 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.683563 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.685272 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.686744 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.688589 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.688827 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.692701 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.693892 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.696683 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.700057 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.701287 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.701401 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.706184 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.708717 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.711126 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.716438 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.716620 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.723988 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.725822 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.729928 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.731551 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.735827 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.739360 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.748935 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.759062 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.769402 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.770998 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.772594 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.774179 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.775706 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.777644 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.779399 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.780886 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.782904 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.784391 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.786162 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.788018 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.792957 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.794576 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.796170 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.797756 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.798702 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.799321 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.801302 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.803094 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.804606 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.806669 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.808198 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.810007 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.811883 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.812760 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.822761 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.826182 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.836759 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.837197 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.850358 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.850461 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.861402 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.864023 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.874563 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.887909 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.892661 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105023.917823 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.246724 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.248474 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.250095 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.251691 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.253470 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.255259 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.257204 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.258989 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.260866 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.263150 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.265474 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.267459 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.270072 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.273868 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.285239 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.288667 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.292148 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.296665 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.301545 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.312622 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.313320 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.313947 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.314704 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.315445 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.316230 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.317010 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.320567 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.324947 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.328637 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.332142 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.335696 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.339056 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.346052 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.410869 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.412595 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.414206 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.415787 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.417574 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.419363 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.421285 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.423043 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.424928 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.427226 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.429550 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.431539 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.434036 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.437696 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.442094 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.443837 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.445459 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.447041 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.448967 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.449086 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.450776 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.452550 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.452752 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.454515 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.456080 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.456429 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.458751 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.460620 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.461096 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.463088 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.465668 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.466450 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.467113 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.467766 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.468371 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.468971 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.469367 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.469681 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.470371 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.471012 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.471510 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.471636 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.472265 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.472424 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.472901 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.473126 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.473687 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.473862 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.474434 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.474643 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.475231 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.475417 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.476022 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.476342 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.477348 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.478368 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.479586 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.479686 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.480429 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.480999 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.482437 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.484005 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.484104 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.484908 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.487764 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.487869 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.488184 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.491253 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.492272 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.492437 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.494805 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.498151 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.503147 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.503848 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.504460 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.505190 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.505286 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.506024 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.506809 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.507590 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.508396 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.508858 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.509317 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.509746 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.510170 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.510592 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.511172 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.511241 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.511680 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.512428 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.514245 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.515587 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.516104 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.518886 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.519259 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.520858 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.522773 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.524699 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.526350 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.528125 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.529725 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.531310 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.536729 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.546249 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.546710 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.547194 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.547644 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.548121 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.548774 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.549249 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.549769 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.550201 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.550647 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.551153 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.551669 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.552155 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.552722 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.553305 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.553906 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.555687 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.556413 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.557254 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.558288 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.563841 2784956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.625653 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.626315 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.626965 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.627565 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.628161 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.628848 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.629549 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.630186 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.630808 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.631479 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.632143 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.632826 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.633596 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.634355 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.635266 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.636286 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.637319 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.638535 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.639805 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.642248 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.645485 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m46s\u001b[0m 570ms/step - loss: 0.0561 - val_loss: 0.2392 - learning_rate: 0.0100\n", + "Epoch 2/400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1727105024.649511 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.658012 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.658663 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.659313 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.660060 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.660674 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.661361 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.662058 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.662691 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.663326 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.663992 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.664660 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.665353 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.665592 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.666303 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.666306 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.666737 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.667128 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.667312 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.668173 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.668288 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.669221 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.670105 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.670300 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.671528 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.671948 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.672815 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.674728 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.675298 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.676717 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.678686 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.678785 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.682656 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.682846 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.685311 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.698731 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.699202 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.699620 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.700223 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.700332 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.700794 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.701229 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.701343 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.701788 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.702254 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.702933 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.703103 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.703418 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.703940 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.704372 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.704917 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.705018 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.705450 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.705975 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.706505 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.707066 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.707761 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.707874 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.708371 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.709866 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.710157 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.710881 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.711801 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.711898 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.712827 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.715743 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.718572 2784938 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.718577 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.733542 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.733997 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.734444 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.734884 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.735346 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.735993 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.736463 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.736978 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.737406 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.737846 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.738358 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.738877 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.739406 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.739969 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.740546 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.741141 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.742917 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.743641 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.744463 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.745479 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727105024.751044 2784911 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 121ms/step - loss: 0.0222" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:23:48.766120: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 138ms/step - loss: 0.0222 - val_loss: 0.0358 - learning_rate: 0.0100\n", + "Epoch 3/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0187 - val_loss: 0.0297 - learning_rate: 0.0100\n", + "Epoch 4/400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:23:53.696177: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 136ms/step - loss: 0.0173 - val_loss: 0.0298 - learning_rate: 0.0100\n", + "Epoch 5/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0167 - val_loss: 0.0296 - learning_rate: 0.0100\n", + "Epoch 6/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 121ms/step - loss: 0.0161" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:24:06.291728: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0161 - val_loss: 0.0292 - learning_rate: 0.0100\n", + "Epoch 7/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0156 - val_loss: 0.0287 - learning_rate: 0.0100\n", + "Epoch 8/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 137ms/step - loss: 0.0152 - val_loss: 0.0292 - learning_rate: 0.0100\n", + "Epoch 9/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0149 - val_loss: 0.0291 - learning_rate: 0.0100\n", + "Epoch 10/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 136ms/step - loss: 0.0145 - val_loss: 0.0299 - learning_rate: 0.0100\n", + "Epoch 11/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0143 - val_loss: 0.0296 - learning_rate: 0.0100\n", + "Epoch 12/400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:24:28.777932: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0140 - val_loss: 0.0297 - learning_rate: 0.0100\n", + "Epoch 13/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0139 - val_loss: 0.0290 - learning_rate: 0.0100\n", + "Epoch 14/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0138 - val_loss: 0.0294 - learning_rate: 0.0100\n", + "Epoch 15/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 136ms/step - loss: 0.0135 - val_loss: 0.0289 - learning_rate: 0.0100\n", + "Epoch 16/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0135 - val_loss: 0.0291 - learning_rate: 0.0100\n", + "Epoch 17/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0134\n", + "Epoch 17: ReduceLROnPlateau reducing learning rate to 0.007999999821186066.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0134 - val_loss: 0.0292 - learning_rate: 0.0100\n", + "Epoch 18/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0131 - val_loss: 0.0289 - learning_rate: 0.0080\n", + "Epoch 19/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0129 - val_loss: 0.0289 - learning_rate: 0.0080\n", + "Epoch 20/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0127 - val_loss: 0.0291 - learning_rate: 0.0080\n", + "Epoch 21/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0127 - val_loss: 0.0288 - learning_rate: 0.0080\n", + "Epoch 22/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 121ms/step - loss: 0.0126" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:25:16.152677: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 136ms/step - loss: 0.0126 - val_loss: 0.0166 - learning_rate: 0.0080\n", + "Epoch 23/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0125 - val_loss: 0.0153 - learning_rate: 0.0080\n", + "Epoch 24/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0125 - val_loss: 0.0289 - learning_rate: 0.0080\n", + "Epoch 25/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 153ms/step - loss: 0.0124 - val_loss: 0.0291 - learning_rate: 0.0080\n", + "Epoch 26/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0123 - val_loss: 0.0291 - learning_rate: 0.0080\n", + "Epoch 27/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0122 - val_loss: 0.0290 - learning_rate: 0.0080\n", + "Epoch 28/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0121 - val_loss: 0.0129 - learning_rate: 0.0080\n", + "Epoch 29/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0121 - val_loss: 0.0257 - learning_rate: 0.0080\n", + "Epoch 30/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0120 - val_loss: 0.0287 - learning_rate: 0.0080\n", + "Epoch 31/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0117 - val_loss: 0.0128 - learning_rate: 0.0080\n", + "Epoch 32/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0117 - val_loss: 0.0196 - learning_rate: 0.0080\n", + "Epoch 33/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0116 - val_loss: 0.0126 - learning_rate: 0.0080\n", + "Epoch 34/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0115 - val_loss: 0.0121 - learning_rate: 0.0080\n", + "Epoch 35/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0113 - val_loss: 0.0121 - learning_rate: 0.0080\n", + "Epoch 36/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0112 - val_loss: 0.0126 - learning_rate: 0.0080\n", + "Epoch 37/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0111 - val_loss: 0.0133 - learning_rate: 0.0080\n", + "Epoch 38/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0109 - val_loss: 0.0289 - learning_rate: 0.0080\n", + "Epoch 39/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0109 - val_loss: 0.0140 - learning_rate: 0.0080\n", + "Epoch 40/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0107 - val_loss: 0.0125 - learning_rate: 0.0080\n", + "Epoch 41/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0106 - val_loss: 0.0136 - learning_rate: 0.0080\n", + "Epoch 42/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0106 - val_loss: 0.0175 - learning_rate: 0.0080\n", + "Epoch 43/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0104 - val_loss: 0.0125 - learning_rate: 0.0080\n", + "Epoch 44/400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:26:48.580810: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0103\n", + "Epoch 44: ReduceLROnPlateau reducing learning rate to 0.006399999558925629.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0103 - val_loss: 0.0132 - learning_rate: 0.0080\n", + "Epoch 45/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0100 - val_loss: 0.0172 - learning_rate: 0.0064\n", + "Epoch 46/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0098 - val_loss: 0.0131 - learning_rate: 0.0064\n", + "Epoch 47/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0096 - val_loss: 0.0465 - learning_rate: 0.0064\n", + "Epoch 48/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0094 - val_loss: 0.0202 - learning_rate: 0.0064\n", + "Epoch 49/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0093 - val_loss: 0.0128 - learning_rate: 0.0064\n", + "Epoch 50/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0092 - val_loss: 0.0135 - learning_rate: 0.0064\n", + "Epoch 51/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0089 - val_loss: 0.0145 - learning_rate: 0.0064\n", + "Epoch 52/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 143ms/step - loss: 0.0088 - val_loss: 0.0443 - learning_rate: 0.0064\n", + "Epoch 53/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0087 - val_loss: 0.0165 - learning_rate: 0.0064\n", + "Epoch 54/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0085\n", + "Epoch 54: ReduceLROnPlateau reducing learning rate to 0.0051199994981288915.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0085 - val_loss: 0.0135 - learning_rate: 0.0064\n", + "Epoch 55/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0082 - val_loss: 0.0143 - learning_rate: 0.0051\n", + "Epoch 56/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0079 - val_loss: 0.0136 - learning_rate: 0.0051\n", + "Epoch 57/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0076 - val_loss: 0.0140 - learning_rate: 0.0051\n", + "Epoch 58/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0075 - val_loss: 0.0135 - learning_rate: 0.0051\n", + "Epoch 59/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0074 - val_loss: 0.0614 - learning_rate: 0.0051\n", + "Epoch 60/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0071 - val_loss: 0.0153 - learning_rate: 0.0051\n", + "Epoch 61/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0071 - val_loss: 0.0140 - learning_rate: 0.0051\n", + "Epoch 62/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0069 - val_loss: 0.0136 - learning_rate: 0.0051\n", + "Epoch 63/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0068 - val_loss: 0.0149 - learning_rate: 0.0051\n", + "Epoch 64/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0067\n", + "Epoch 64: ReduceLROnPlateau reducing learning rate to 0.004095999523997307.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0067 - val_loss: 0.0153 - learning_rate: 0.0051\n", + "Epoch 65/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0065 - val_loss: 0.0160 - learning_rate: 0.0041\n", + "Epoch 66/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0061 - val_loss: 0.0137 - learning_rate: 0.0041\n", + "Epoch 67/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0058 - val_loss: 0.0158 - learning_rate: 0.0041\n", + "Epoch 68/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 157ms/step - loss: 0.0057 - val_loss: 0.0144 - learning_rate: 0.0041\n", + "Epoch 69/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0056 - val_loss: 0.0136 - learning_rate: 0.0041\n", + "Epoch 70/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0054 - val_loss: 0.0139 - learning_rate: 0.0041\n", + "Epoch 71/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0053 - val_loss: 0.0136 - learning_rate: 0.0041\n", + "Epoch 72/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0051 - val_loss: 0.0142 - learning_rate: 0.0041\n", + "Epoch 73/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0051 - val_loss: 0.0156 - learning_rate: 0.0041\n", + "Epoch 74/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0049\n", + "Epoch 74: ReduceLROnPlateau reducing learning rate to 0.0032767996191978457.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0049 - val_loss: 0.0142 - learning_rate: 0.0041\n", + "Epoch 75/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0048 - val_loss: 0.0149 - learning_rate: 0.0033\n", + "Epoch 76/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0045 - val_loss: 0.0175 - learning_rate: 0.0033\n", + "Epoch 77/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0044 - val_loss: 0.0136 - learning_rate: 0.0033\n", + "Epoch 78/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0043 - val_loss: 0.0146 - learning_rate: 0.0033\n", + "Epoch 79/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0042 - val_loss: 0.0142 - learning_rate: 0.0033\n", + "Epoch 80/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0041 - val_loss: 0.0152 - learning_rate: 0.0033\n", + "Epoch 81/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0040 - val_loss: 0.0192 - learning_rate: 0.0033\n", + "Epoch 82/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0039 - val_loss: 0.0138 - learning_rate: 0.0033\n", + "Epoch 83/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0039 - val_loss: 0.0161 - learning_rate: 0.0033\n", + "Epoch 84/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0038\n", + "Epoch 84: ReduceLROnPlateau reducing learning rate to 0.0026214396581053737.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0038 - val_loss: 0.0156 - learning_rate: 0.0033\n", + "Epoch 85/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0037 - val_loss: 0.0136 - learning_rate: 0.0026\n", + "Epoch 86/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0035" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:29:55.287839: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0035 - val_loss: 0.0143 - learning_rate: 0.0026\n", + "Epoch 87/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0034 - val_loss: 0.0135 - learning_rate: 0.0026\n", + "Epoch 88/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0034 - val_loss: 0.0135 - learning_rate: 0.0026\n", + "Epoch 89/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0033 - val_loss: 0.0146 - learning_rate: 0.0026\n", + "Epoch 90/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0033 - val_loss: 0.0135 - learning_rate: 0.0026\n", + "Epoch 91/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0032 - val_loss: 0.0144 - learning_rate: 0.0026\n", + "Epoch 92/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0032 - val_loss: 0.0145 - learning_rate: 0.0026\n", + "Epoch 93/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0031 - val_loss: 0.0137 - learning_rate: 0.0026\n", + "Epoch 94/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0030\n", + "Epoch 94: ReduceLROnPlateau reducing learning rate to 0.0020971518009901048.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0030 - val_loss: 0.0138 - learning_rate: 0.0026\n", + "Epoch 95/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0030 - val_loss: 0.0141 - learning_rate: 0.0021\n", + "Epoch 96/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0029 - val_loss: 0.0148 - learning_rate: 0.0021\n", + "Epoch 97/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0029 - val_loss: 0.0139 - learning_rate: 0.0021\n", + "Epoch 98/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0028 - val_loss: 0.0138 - learning_rate: 0.0021\n", + "Epoch 99/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0028 - val_loss: 0.0146 - learning_rate: 0.0021\n", + "Epoch 100/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0027 - val_loss: 0.0138 - learning_rate: 0.0021\n", + "Epoch 101/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0027 - val_loss: 0.0146 - learning_rate: 0.0021\n", + "Epoch 102/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0027 - val_loss: 0.0145 - learning_rate: 0.0021\n", + "Epoch 103/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0027 - val_loss: 0.0146 - learning_rate: 0.0021\n", + "Epoch 104/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0026\n", + "Epoch 104: ReduceLROnPlateau reducing learning rate to 0.0016777213662862779.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0026 - val_loss: 0.0135 - learning_rate: 0.0021\n", + "Epoch 105/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0026 - val_loss: 0.0147 - learning_rate: 0.0017\n", + "Epoch 106/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0025 - val_loss: 0.0139 - learning_rate: 0.0017\n", + "Epoch 107/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0025 - val_loss: 0.0154 - learning_rate: 0.0017\n", + "Epoch 108/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 143ms/step - loss: 0.0025 - val_loss: 0.0144 - learning_rate: 0.0017\n", + "Epoch 109/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0024 - val_loss: 0.0146 - learning_rate: 0.0017\n", + "Epoch 110/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0024 - val_loss: 0.0137 - learning_rate: 0.0017\n", + "Epoch 111/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 158ms/step - loss: 0.0024 - val_loss: 0.0145 - learning_rate: 0.0017\n", + "Epoch 112/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0024 - val_loss: 0.0143 - learning_rate: 0.0017\n", + "Epoch 113/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 144ms/step - loss: 0.0024 - val_loss: 0.0141 - learning_rate: 0.0017\n", + "Epoch 114/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0023\n", + "Epoch 114: ReduceLROnPlateau reducing learning rate to 0.0013421771116554739.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 140ms/step - loss: 0.0023 - val_loss: 0.0139 - learning_rate: 0.0017\n", + "Epoch 115/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0023 - val_loss: 0.0138 - learning_rate: 0.0013\n", + "Epoch 116/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0022 - val_loss: 0.0135 - learning_rate: 0.0013\n", + "Epoch 117/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0022 - val_loss: 0.0142 - learning_rate: 0.0013\n", + "Epoch 118/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0022 - val_loss: 0.0141 - learning_rate: 0.0013\n", + "Epoch 119/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0022 - val_loss: 0.0140 - learning_rate: 0.0013\n", + "Epoch 120/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0022 - val_loss: 0.0143 - learning_rate: 0.0013\n", + "Epoch 121/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0021 - val_loss: 0.0135 - learning_rate: 0.0013\n", + "Epoch 122/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0022 - val_loss: 0.0143 - learning_rate: 0.0013\n", + "Epoch 123/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0021 - val_loss: 0.0141 - learning_rate: 0.0013\n", + "Epoch 124/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0021\n", + "Epoch 124: ReduceLROnPlateau reducing learning rate to 0.001073741726577282.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0021 - val_loss: 0.0141 - learning_rate: 0.0013\n", + "Epoch 125/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 140ms/step - loss: 0.0021 - val_loss: 0.0144 - learning_rate: 0.0011\n", + "Epoch 126/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0021 - val_loss: 0.0145 - learning_rate: 0.0011\n", + "Epoch 127/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0020 - val_loss: 0.0149 - learning_rate: 0.0011\n", + "Epoch 128/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0020 - val_loss: 0.0140 - learning_rate: 0.0011\n", + "Epoch 129/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0020 - val_loss: 0.0142 - learning_rate: 0.0011\n", + "Epoch 130/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0020 - val_loss: 0.0143 - learning_rate: 0.0011\n", + "Epoch 131/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0020 - val_loss: 0.0143 - learning_rate: 0.0011\n", + "Epoch 132/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0020 - val_loss: 0.0141 - learning_rate: 0.0011\n", + "Epoch 133/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0020 - val_loss: 0.0137 - learning_rate: 0.0011\n", + "Epoch 134/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0019\n", + "Epoch 134: ReduceLROnPlateau reducing learning rate to 0.0008589933626353742.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 139ms/step - loss: 0.0019 - val_loss: 0.0142 - learning_rate: 0.0011\n", + "Epoch 135/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0019 - val_loss: 0.0139 - learning_rate: 8.5899e-04\n", + "Epoch 136/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0019 - val_loss: 0.0133 - learning_rate: 8.5899e-04\n", + "Epoch 137/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0019 - val_loss: 0.0136 - learning_rate: 8.5899e-04\n", + "Epoch 138/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0019 - val_loss: 0.0139 - learning_rate: 8.5899e-04\n", + "Epoch 139/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0019 - val_loss: 0.0138 - learning_rate: 8.5899e-04\n", + "Epoch 140/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 144ms/step - loss: 0.0018 - val_loss: 0.0139 - learning_rate: 8.5899e-04\n", + "Epoch 141/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 140ms/step - loss: 0.0019 - val_loss: 0.0135 - learning_rate: 8.5899e-04\n", + "Epoch 142/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0019 - val_loss: 0.0138 - learning_rate: 8.5899e-04\n", + "Epoch 143/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0019 - val_loss: 0.0145 - learning_rate: 8.5899e-04\n", + "Epoch 144/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0018\n", + "Epoch 144: ReduceLROnPlateau reducing learning rate to 0.0006871947087347508.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0018 - val_loss: 0.0141 - learning_rate: 8.5899e-04\n", + "Epoch 145/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0018 - val_loss: 0.0134 - learning_rate: 6.8719e-04\n", + "Epoch 146/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0018 - val_loss: 0.0137 - learning_rate: 6.8719e-04\n", + "Epoch 147/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0018 - val_loss: 0.0138 - learning_rate: 6.8719e-04\n", + "Epoch 148/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0018 - val_loss: 0.0140 - learning_rate: 6.8719e-04\n", + "Epoch 149/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0018 - val_loss: 0.0140 - learning_rate: 6.8719e-04\n", + "Epoch 150/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 138ms/step - loss: 0.0018 - val_loss: 0.0140 - learning_rate: 6.8719e-04\n", + "Epoch 151/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0018 - val_loss: 0.0146 - learning_rate: 6.8719e-04\n", + "Epoch 152/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0017 - val_loss: 0.0141 - learning_rate: 6.8719e-04\n", + "Epoch 153/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0017 - val_loss: 0.0136 - learning_rate: 6.8719e-04\n", + "Epoch 154/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0017\n", + "Epoch 154: ReduceLROnPlateau reducing learning rate to 0.0005497557576745749.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0017 - val_loss: 0.0139 - learning_rate: 6.8719e-04\n", + "Epoch 155/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0017 - val_loss: 0.0142 - learning_rate: 5.4976e-04\n", + "Epoch 156/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0017 - val_loss: 0.0145 - learning_rate: 5.4976e-04\n", + "Epoch 157/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0017 - val_loss: 0.0141 - learning_rate: 5.4976e-04\n", + "Epoch 158/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0017 - val_loss: 0.0141 - learning_rate: 5.4976e-04\n", + "Epoch 159/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0017 - val_loss: 0.0143 - learning_rate: 5.4976e-04\n", + "Epoch 160/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0017 - val_loss: 0.0140 - learning_rate: 5.4976e-04\n", + "Epoch 161/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0016 - val_loss: 0.0145 - learning_rate: 5.4976e-04\n", + "Epoch 162/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0016 - val_loss: 0.0137 - learning_rate: 5.4976e-04\n", + "Epoch 163/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0016 - val_loss: 0.0149 - learning_rate: 5.4976e-04\n", + "Epoch 164/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0017\n", + "Epoch 164: ReduceLROnPlateau reducing learning rate to 0.0004398046061396599.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0017 - val_loss: 0.0142 - learning_rate: 5.4976e-04\n", + "Epoch 165/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0016 - val_loss: 0.0150 - learning_rate: 4.3980e-04\n", + "Epoch 166/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0016 - val_loss: 0.0138 - learning_rate: 4.3980e-04\n", + "Epoch 167/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0016 - val_loss: 0.0138 - learning_rate: 4.3980e-04\n", + "Epoch 168/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0016 - val_loss: 0.0139 - learning_rate: 4.3980e-04\n", + "Epoch 169/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0016 - val_loss: 0.0139 - learning_rate: 4.3980e-04\n", + "Epoch 170/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0016 - val_loss: 0.0139 - learning_rate: 4.3980e-04\n", + "Epoch 171/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0016 - val_loss: 0.0140 - learning_rate: 4.3980e-04\n", + "Epoch 172/400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:36:08.445125: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0016 - val_loss: 0.0140 - learning_rate: 4.3980e-04\n", + "Epoch 173/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0016 - val_loss: 0.0142 - learning_rate: 4.3980e-04\n", + "Epoch 174/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0016\n", + "Epoch 174: ReduceLROnPlateau reducing learning rate to 0.00035184368025511505.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0016 - val_loss: 0.0140 - learning_rate: 4.3980e-04\n", + "Epoch 175/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 136ms/step - loss: 0.0016 - val_loss: 0.0142 - learning_rate: 3.5184e-04\n", + "Epoch 176/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0016 - val_loss: 0.0141 - learning_rate: 3.5184e-04\n", + "Epoch 177/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0015 - val_loss: 0.0139 - learning_rate: 3.5184e-04\n", + "Epoch 178/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0015 - val_loss: 0.0139 - learning_rate: 3.5184e-04\n", + "Epoch 179/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0015 - val_loss: 0.0140 - learning_rate: 3.5184e-04\n", + "Epoch 180/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0015 - val_loss: 0.0137 - learning_rate: 3.5184e-04\n", + "Epoch 181/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0015 - val_loss: 0.0142 - learning_rate: 3.5184e-04\n", + "Epoch 182/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0015 - val_loss: 0.0140 - learning_rate: 3.5184e-04\n", + "Epoch 183/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0015 - val_loss: 0.0144 - learning_rate: 3.5184e-04\n", + "Epoch 184/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0015\n", + "Epoch 184: ReduceLROnPlateau reducing learning rate to 0.0002814749488607049.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0015 - val_loss: 0.0140 - learning_rate: 3.5184e-04\n", + "Epoch 185/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0015 - val_loss: 0.0147 - learning_rate: 2.8147e-04\n", + "Epoch 186/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0015 - val_loss: 0.0140 - learning_rate: 2.8147e-04\n", + "Epoch 187/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0015 - val_loss: 0.0137 - learning_rate: 2.8147e-04\n", + "Epoch 188/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 139ms/step - loss: 0.0015 - val_loss: 0.0141 - learning_rate: 2.8147e-04\n", + "Epoch 189/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0015 - val_loss: 0.0137 - learning_rate: 2.8147e-04\n", + "Epoch 190/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0015 - val_loss: 0.0144 - learning_rate: 2.8147e-04\n", + "Epoch 191/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0015 - val_loss: 0.0137 - learning_rate: 2.8147e-04\n", + "Epoch 192/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0015 - val_loss: 0.0141 - learning_rate: 2.8147e-04\n", + "Epoch 193/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0015 - val_loss: 0.0142 - learning_rate: 2.8147e-04\n", + "Epoch 194/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0015\n", + "Epoch 194: ReduceLROnPlateau reducing learning rate to 0.0002251799684017897.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0015 - val_loss: 0.0138 - learning_rate: 2.8147e-04\n", + "Epoch 195/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0015 - val_loss: 0.0143 - learning_rate: 2.2518e-04\n", + "Epoch 196/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0015 - val_loss: 0.0144 - learning_rate: 2.2518e-04\n", + "Epoch 197/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0142 - learning_rate: 2.2518e-04\n", + "Epoch 198/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0015 - val_loss: 0.0138 - learning_rate: 2.2518e-04\n", + "Epoch 199/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0015 - val_loss: 0.0142 - learning_rate: 2.2518e-04\n", + "Epoch 200/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0015 - val_loss: 0.0140 - learning_rate: 2.2518e-04\n", + "Epoch 201/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0015 - val_loss: 0.0137 - learning_rate: 2.2518e-04\n", + "Epoch 202/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0138 - learning_rate: 2.2518e-04\n", + "Epoch 203/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0148 - learning_rate: 2.2518e-04\n", + "Epoch 204/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 125ms/step - loss: 0.0014\n", + "Epoch 204: ReduceLROnPlateau reducing learning rate to 0.0001801439793780446.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0138 - learning_rate: 2.2518e-04\n", + "Epoch 205/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0139 - learning_rate: 1.8014e-04\n", + "Epoch 206/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0014 - val_loss: 0.0145 - learning_rate: 1.8014e-04\n", + "Epoch 207/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0014 - val_loss: 0.0143 - learning_rate: 1.8014e-04\n", + "Epoch 208/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0014 - val_loss: 0.0142 - learning_rate: 1.8014e-04\n", + "Epoch 209/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0014 - val_loss: 0.0135 - learning_rate: 1.8014e-04\n", + "Epoch 210/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0014 - val_loss: 0.0143 - learning_rate: 1.8014e-04\n", + "Epoch 211/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0145 - learning_rate: 1.8014e-04\n", + "Epoch 212/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0136 - learning_rate: 1.8014e-04\n", + "Epoch 213/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0014 - val_loss: 0.0142 - learning_rate: 1.8014e-04\n", + "Epoch 214/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0014\n", + "Epoch 214: ReduceLROnPlateau reducing learning rate to 0.00014411518350243568.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0140 - learning_rate: 1.8014e-04\n", + "Epoch 215/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0014 - val_loss: 0.0140 - learning_rate: 1.4412e-04\n", + "Epoch 216/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 143ms/step - loss: 0.0014 - val_loss: 0.0140 - learning_rate: 1.4412e-04\n", + "Epoch 217/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 142ms/step - loss: 0.0014 - val_loss: 0.0145 - learning_rate: 1.4412e-04\n", + "Epoch 218/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0014 - val_loss: 0.0138 - learning_rate: 1.4412e-04\n", + "Epoch 219/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0014 - val_loss: 0.0143 - learning_rate: 1.4412e-04\n", + "Epoch 220/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0141 - learning_rate: 1.4412e-04\n", + "Epoch 221/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0142 - learning_rate: 1.4412e-04\n", + "Epoch 222/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0014 - val_loss: 0.0138 - learning_rate: 1.4412e-04\n", + "Epoch 223/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0014 - val_loss: 0.0139 - learning_rate: 1.4412e-04\n", + "Epoch 224/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0014\n", + "Epoch 224: ReduceLROnPlateau reducing learning rate to 0.00011529214680194855.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0014 - val_loss: 0.0139 - learning_rate: 1.4412e-04\n", + "Epoch 225/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0014 - val_loss: 0.0146 - learning_rate: 1.1529e-04\n", + "Epoch 226/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 138ms/step - loss: 0.0014 - val_loss: 0.0139 - learning_rate: 1.1529e-04\n", + "Epoch 227/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0137 - learning_rate: 1.1529e-04\n", + "Epoch 228/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0014 - val_loss: 0.0138 - learning_rate: 1.1529e-04\n", + "Epoch 229/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0014 - val_loss: 0.0140 - learning_rate: 1.1529e-04\n", + "Epoch 230/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0014 - val_loss: 0.0140 - learning_rate: 1.1529e-04\n", + "Epoch 231/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0143 - learning_rate: 1.1529e-04\n", + "Epoch 232/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0139 - learning_rate: 1.1529e-04\n", + "Epoch 233/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0142 - learning_rate: 1.1529e-04\n", + "Epoch 234/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0014\n", + "Epoch 234: ReduceLROnPlateau reducing learning rate to 9.223371744155885e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0014 - val_loss: 0.0137 - learning_rate: 1.1529e-04\n", + "Epoch 235/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0014 - val_loss: 0.0138 - learning_rate: 9.2234e-05\n", + "Epoch 236/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 9.2234e-05\n", + "Epoch 237/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 9.2234e-05\n", + "Epoch 238/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 9.2234e-05\n", + "Epoch 239/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0136 - learning_rate: 9.2234e-05\n", + "Epoch 240/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0014 - val_loss: 0.0142 - learning_rate: 9.2234e-05\n", + "Epoch 241/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0145 - learning_rate: 9.2234e-05\n", + "Epoch 242/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 9.2234e-05\n", + "Epoch 243/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 9.2234e-05\n", + "Epoch 244/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 244: ReduceLROnPlateau reducing learning rate to 7.378697628155351e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 9.2234e-05\n", + "Epoch 245/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 7.3787e-05\n", + "Epoch 246/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 7.3787e-05\n", + "Epoch 247/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 7.3787e-05\n", + "Epoch 248/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 7.3787e-05\n", + "Epoch 249/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 7.3787e-05\n", + "Epoch 250/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 7.3787e-05\n", + "Epoch 251/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 7.3787e-05\n", + "Epoch 252/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 7.3787e-05\n", + "Epoch 253/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 7.3787e-05\n", + "Epoch 254/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 254: ReduceLROnPlateau reducing learning rate to 5.9029582189396024e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 7.3787e-05\n", + "Epoch 255/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 5.9030e-05\n", + "Epoch 256/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 5.9030e-05\n", + "Epoch 257/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 5.9030e-05\n", + "Epoch 258/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 5.9030e-05\n", + "Epoch 259/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 5.9030e-05\n", + "Epoch 260/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 5.9030e-05\n", + "Epoch 261/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 5.9030e-05\n", + "Epoch 262/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 5.9030e-05\n", + "Epoch 263/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 5.9030e-05\n", + "Epoch 264/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0013\n", + "Epoch 264: ReduceLROnPlateau reducing learning rate to 4.722366575151682e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 5.9030e-05\n", + "Epoch 265/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 4.7224e-05\n", + "Epoch 266/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 4.7224e-05\n", + "Epoch 267/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 4.7224e-05\n", + "Epoch 268/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 4.7224e-05\n", + "Epoch 269/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 4.7224e-05\n", + "Epoch 270/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 4.7224e-05\n", + "Epoch 271/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 4.7224e-05\n", + "Epoch 272/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 4.7224e-05\n", + "Epoch 273/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 4.7224e-05\n", + "Epoch 274/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 121ms/step - loss: 0.0013\n", + "Epoch 274: ReduceLROnPlateau reducing learning rate to 3.777893143706024e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 4.7224e-05\n", + "Epoch 275/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 3.7779e-05\n", + "Epoch 276/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 3.7779e-05\n", + "Epoch 277/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 3.7779e-05\n", + "Epoch 278/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 3.7779e-05\n", + "Epoch 279/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 3.7779e-05\n", + "Epoch 280/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 3.7779e-05\n", + "Epoch 281/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 3.7779e-05\n", + "Epoch 282/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 3.7779e-05\n", + "Epoch 283/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 3.7779e-05\n", + "Epoch 284/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 284: ReduceLROnPlateau reducing learning rate to 3.022314631380141e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 3.7779e-05\n", + "Epoch 285/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 3.0223e-05\n", + "Epoch 286/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 3.0223e-05\n", + "Epoch 287/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 137ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 3.0223e-05\n", + "Epoch 288/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 3.0223e-05\n", + "Epoch 289/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 3.0223e-05\n", + "Epoch 290/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 3.0223e-05\n", + "Epoch 291/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 3.0223e-05\n", + "Epoch 292/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 3.0223e-05\n", + "Epoch 293/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 3.0223e-05\n", + "Epoch 294/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 294: ReduceLROnPlateau reducing learning rate to 2.4178516468964517e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 3.0223e-05\n", + "Epoch 295/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 2.4179e-05\n", + "Epoch 296/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 2.4179e-05\n", + "Epoch 297/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 2.4179e-05\n", + "Epoch 298/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 2.4179e-05\n", + "Epoch 299/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 2.4179e-05\n", + "Epoch 300/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 2.4179e-05\n", + "Epoch 301/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 2.4179e-05\n", + "Epoch 302/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 2.4179e-05\n", + "Epoch 303/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 2.4179e-05\n", + "Epoch 304/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 304: ReduceLROnPlateau reducing learning rate to 1.9342813175171614e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 2.4179e-05\n", + "Epoch 305/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 1.9343e-05\n", + "Epoch 306/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 1.9343e-05\n", + "Epoch 307/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 1.9343e-05\n", + "Epoch 308/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 1.9343e-05\n", + "Epoch 309/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 1.9343e-05\n", + "Epoch 310/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0148 - learning_rate: 1.9343e-05\n", + "Epoch 311/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0136 - learning_rate: 1.9343e-05\n", + "Epoch 312/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 1.9343e-05\n", + "Epoch 313/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 1.9343e-05\n", + "Epoch 314/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0013\n", + "Epoch 314: ReduceLROnPlateau reducing learning rate to 1.5474250540137293e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 1.9343e-05\n", + "Epoch 315/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 1.5474e-05\n", + "Epoch 316/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 1.5474e-05\n", + "Epoch 317/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 1.5474e-05\n", + "Epoch 318/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 1.5474e-05\n", + "Epoch 319/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 1.5474e-05\n", + "Epoch 320/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 1.5474e-05\n", + "Epoch 321/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 1.5474e-05\n", + "Epoch 322/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 1.5474e-05\n", + "Epoch 323/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 1.5474e-05\n", + "Epoch 324/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 324: ReduceLROnPlateau reducing learning rate to 1.2379400141071529e-05.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 1.5474e-05\n", + "Epoch 325/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 1.2379e-05\n", + "Epoch 326/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 1.2379e-05\n", + "Epoch 327/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 1.2379e-05\n", + "Epoch 328/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0145 - learning_rate: 1.2379e-05\n", + "Epoch 329/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 1.2379e-05\n", + "Epoch 330/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 1.2379e-05\n", + "Epoch 331/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 1.2379e-05\n", + "Epoch 332/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0136 - learning_rate: 1.2379e-05\n", + "Epoch 333/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0136 - learning_rate: 1.2379e-05\n", + "Epoch 334/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 122ms/step - loss: 0.0013\n", + "Epoch 334: ReduceLROnPlateau reducing learning rate to 9.903519821818919e-06.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 1.2379e-05\n", + "Epoch 335/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0136 - learning_rate: 9.9035e-06\n", + "Epoch 336/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0145 - learning_rate: 9.9035e-06\n", + "Epoch 337/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 9.9035e-06\n", + "Epoch 338/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 9.9035e-06\n", + "Epoch 339/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 9.9035e-06\n", + "Epoch 340/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0145 - learning_rate: 9.9035e-06\n", + "Epoch 341/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 9.9035e-06\n", + "Epoch 342/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 9.9035e-06\n", + "Epoch 343/400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-23 15:48:34.109381: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 9.9035e-06\n", + "Epoch 344/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 344: ReduceLROnPlateau reducing learning rate to 7.922815711935982e-06.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 9.9035e-06\n", + "Epoch 345/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 7.9228e-06\n", + "Epoch 346/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 7.9228e-06\n", + "Epoch 347/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 7.9228e-06\n", + "Epoch 348/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 7.9228e-06\n", + "Epoch 349/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0145 - learning_rate: 7.9228e-06\n", + "Epoch 350/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 7.9228e-06\n", + "Epoch 351/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0136 - learning_rate: 7.9228e-06\n", + "Epoch 352/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 7.9228e-06\n", + "Epoch 353/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 7.9228e-06\n", + "Epoch 354/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0013\n", + "Epoch 354: ReduceLROnPlateau reducing learning rate to 6.338252569548786e-06.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 7.9228e-06\n", + "Epoch 355/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 6.3383e-06\n", + "Epoch 356/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 6.3383e-06\n", + "Epoch 357/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 6.3383e-06\n", + "Epoch 358/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 6.3383e-06\n", + "Epoch 359/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 6.3383e-06\n", + "Epoch 360/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0145 - learning_rate: 6.3383e-06\n", + "Epoch 361/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 6.3383e-06\n", + "Epoch 362/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 6.3383e-06\n", + "Epoch 363/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 6.3383e-06\n", + "Epoch 364/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 364: ReduceLROnPlateau reducing learning rate to 5.070602128398605e-06.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 6.3383e-06\n", + "Epoch 365/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 5.0706e-06\n", + "Epoch 366/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 5.0706e-06\n", + "Epoch 367/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 5.0706e-06\n", + "Epoch 368/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 5.0706e-06\n", + "Epoch 369/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 142ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 5.0706e-06\n", + "Epoch 370/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 5.0706e-06\n", + "Epoch 371/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 5.0706e-06\n", + "Epoch 372/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 5.0706e-06\n", + "Epoch 373/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 5.0706e-06\n", + "Epoch 374/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 374: ReduceLROnPlateau reducing learning rate to 4.056481702718884e-06.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 5.0706e-06\n", + "Epoch 375/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 4.0565e-06\n", + "Epoch 376/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 4.0565e-06\n", + "Epoch 377/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0134 - learning_rate: 4.0565e-06\n", + "Epoch 378/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 4.0565e-06\n", + "Epoch 379/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 4.0565e-06\n", + "Epoch 380/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 4.0565e-06\n", + "Epoch 381/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0139 - learning_rate: 4.0565e-06\n", + "Epoch 382/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0144 - learning_rate: 4.0565e-06\n", + "Epoch 383/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 4.0565e-06\n", + "Epoch 384/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 123ms/step - loss: 0.0013\n", + "Epoch 384: ReduceLROnPlateau reducing learning rate to 3.2451855076942595e-06.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 4.0565e-06\n", + "Epoch 385/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0137 - learning_rate: 3.2452e-06\n", + "Epoch 386/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 3.2452e-06\n", + "Epoch 387/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 3.2452e-06\n", + "Epoch 388/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 3.2452e-06\n", + "Epoch 389/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 3.2452e-06\n", + "Epoch 390/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 3.2452e-06\n", + "Epoch 391/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0141 - learning_rate: 3.2452e-06\n", + "Epoch 392/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 142ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 3.2452e-06\n", + "Epoch 393/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 3.2452e-06\n", + "Epoch 394/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 124ms/step - loss: 0.0013\n", + "Epoch 394: ReduceLROnPlateau reducing learning rate to 2.596148442535196e-06.\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 141ms/step - loss: 0.0013 - val_loss: 0.0143 - learning_rate: 3.2452e-06\n", + "Epoch 395/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 140ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 2.5961e-06\n", + "Epoch 396/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0140 - learning_rate: 2.5961e-06\n", + "Epoch 397/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0146 - learning_rate: 2.5961e-06\n", + "Epoch 398/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 138ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 2.5961e-06\n", + "Epoch 399/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0138 - learning_rate: 2.5961e-06\n", + "Epoch 400/400\n", + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0013 - val_loss: 0.0142 - learning_rate: 2.5961e-06\n" + ] + } + ], + "source": [ + "\n", + "# Train the model\n", + "history = model_builder.train_model(\n", + " train_dataset, \n", + " val_dataset, \n", + " epochs=400,\n", + " callbacks_list=[lr_scheduler]\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# Extract the losses from the history object\n", + "train_loss = history.history['loss']\n", + "val_loss = history.history['val_loss']\n", + "\n", + "\n", + "train_loss_x_midpoints = history.history.get('x_midpoints_reshape_loss', train_loss)\n", + "val_loss_x_midpoints = history.history.get('val_x_midpoints_reshape_loss', val_loss)\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "plt.subplot(1, 2,1)\n", + "plt.plot(train_loss_x_midpoints, label='Train Loss x_midpoints_reshape')\n", + "plt.plot(val_loss_x_midpoints, label='Validation Loss x_midpoints_reshape')\n", + "plt.xlabel('Epochs')\n", + "plt.yscale('log')\n", + "\n", + "plt.ylabel('Loss')\n", + "plt.title('Training and Validation Loss ')\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "loaded_model = tf.keras.models.load_model(\n", + " \"/home/da886/Final Electron counting project/Experimental weights/Josh5fixedCustomloss.keras\",\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# model_builder.model.save('/home/da886/Final Electron counting project/Experimental weights/JoshMSE5fixed.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n" + ] + } + ], + "source": [ + "# # train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "# # train_dataset = train_dataset.batch(800)\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", + "# val_dataset = val_dataset.batch(800)\n", + "# inputs,targets = next(iter(val_dataset))\n", + "# outputs = loademodel.predict(inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "\n", + "# def visualize_midpoints(image, midpoints):\n", + "# \"\"\"\n", + "# Visualizes midpoints on an image without using a probability vector.\n", + "\n", + "# Parameters:\n", + "# - image: A 3D tensor representing the image.\n", + "# - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + "\n", + "# Returns:\n", + "# None (displays the image with midpoints).\n", + "# \"\"\"\n", + "# # Convert to NumPy arrays for easier handling\n", + "# image_np = image\n", + "# midpoints_np = midpoints\n", + "\n", + "# # Denormalize image if necessary (adjust based on your normalization method)\n", + "# denormalized_image = image_np # Modify if normalization was applied during training\n", + "\n", + "# # Visualize the image\n", + "# plt.figure(figsize=(4, 4))\n", + "# plt.imshow(denormalized_image, cmap='gray')\n", + "# plt.title(\"Predicted Midpoint Visualization\")\n", + "\n", + "# # Plot midpoints directly\n", + "# for i, (x, y) in enumerate(midpoints_np):\n", + "# plt.scatter(x, y, color='red', s=5)\n", + "\n", + "# plt.show()\n", + "\n", + "# def visualize_midpoints2(image, midpoints):\n", + "# \"\"\"\n", + "# Visualizes ground truth midpoints on an image without using a probability vector.\n", + "\n", + "# Parameters:\n", + "# - image: A 3D tensor representing the image.\n", + "# - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + "\n", + "# Returns:\n", + "# None (displays the image with midpoints).\n", + "# \"\"\"\n", + " \n", + "# image_np = image\n", + "# midpoints_np = midpoints\n", + "# denormalized_image = image_np \n", + "\n", + "# # Visualize the image\n", + "# plt.figure(figsize=(4, 4))\n", + "# plt.imshow(denormalized_image, cmap='gray')\n", + "# plt.title(\"Ground Truth Midpoint Visualization\")\n", + "\n", + "# # Plot midpoints directly\n", + "# for i, (x, y) in enumerate(midpoints_np):\n", + "# plt.scatter(x, y, color='red', s=5)\n", + "\n", + "# plt.show()\n", + "\n", + "# # Example usage with random data\n", + "# t = np.random.randint(0, 800)\n", + "# # t=100\n", + "\n", + "# visualize_midpoints(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(outputs[t,0,:,:])*64)\n", + "# visualize_midpoints2(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(targets[t,0,:,:])*64)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing batch 1, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1727205825.025916 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.041518 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.041841 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.045200 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.045498 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.045780 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.046061 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.046399 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.046722 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.047083 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.047418 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.055233 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.055559 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.055835 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.056087 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.056429 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.056748 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.057108 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.057498 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.057830 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.058267 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.058684 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.059186 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.067586 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.068092 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.068582 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.069059 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.069526 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.070049 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.071405 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.071933 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.072621 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.073317 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.074217 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.075018 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.075840 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.076674 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.077460 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.078239 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.079151 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.080170 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.081077 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.081875 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.083530 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.083862 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.084891 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.085288 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205825.086659 1430162 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing batch 2, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 968us/step\n", + "Processing batch 3, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 917us/step\n", + "Processing batch 4, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 833us/step\n", + "Processing batch 5, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 712us/step\n", + "Processing batch 6, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 658us/step\n", + "Processing batch 7, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 813us/step\n", + "Processing batch 8, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 807us/step\n", + "Processing batch 9, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 919us/step\n", + "Processing batch 10, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "Processing batch 11, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 959us/step\n", + "Processing batch 12, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 956us/step\n", + "Processing batch 13, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 678us/step\n", + "Processing batch 14, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 722us/step\n", + "Processing batch 15, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 951us/step\n", + "Processing batch 16, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 937us/step\n", + "Processing batch 17, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 998us/step\n", + "Processing batch 18, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 953us/step\n", + "Processing batch 19, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 971us/step\n", + "Processing batch 20, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 736us/step\n", + "Processing batch 21, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 931us/step\n", + "Processing batch 22, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "Processing batch 23, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 916us/step\n", + "Processing batch 24, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 996us/step\n", + "Processing batch 25, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "Processing batch 26, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 872us/step\n", + "Processing batch 27, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 730us/step\n", + "Processing batch 28, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 984us/step\n", + "Processing batch 29, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 670us/step\n", + "Processing batch 30, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 696us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-24 19:23:48.052990: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "# Define the function for visualizing midpoints\n", + "def visualize_midpoints(image, midpoints, title=\"Predicted Midpoint Visualization\"):\n", + " \"\"\"\n", + " Visualizes midpoints on an image without using a probability vector.\n", + "\n", + " Parameters:\n", + " - image: A 3D tensor representing the image.\n", + " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + " - title: The title of the plot.\n", + "\n", + " Returns:\n", + " None (displays the image with midpoints).\n", + " \"\"\"\n", + " # Convert to NumPy arrays for easier handling\n", + " image_np = image\n", + " midpoints_np = midpoints\n", + "\n", + " # Denormalize image if necessary (adjust based on your normalization method)\n", + " denormalized_image = image_np # Modify if normalization was applied during training\n", + "\n", + " # Visualize the image\n", + " plt.figure(figsize=(4, 4))\n", + " plt.imshow(denormalized_image, cmap='gray')\n", + " plt.title(title)\n", + "\n", + " # Plot midpoints directly, only if they are not (0, 0)\n", + " for i, (x, y) in enumerate(midpoints_np):\n", + " if x >= 3 and y >= 3: # Only plot if the point is not (0, 0)\n", + " plt.scatter(x, y, color='red', s=5)\n", + "\n", + " plt.show()\n", + "\n", + "# Create the validation dataset\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", + "# val_dataset = val_dataset.batch(800)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "train_dataset = train_dataset.batch(800)\n", + "\n", + "# Initialize lists to collect the data\n", + "all_images = []\n", + "all_true_midpoints = []\n", + "all_pred_midpoints = []\n", + "\n", + "# Loop through each batch in the validation dataset, predict, and collect results\n", + "# for i, (data_batch, midpoints_batch) in enumerate(val_dataset):\n", + "\n", + "for i, (data_batch, midpoints_batch) in enumerate(train_dataset):\n", + " print(f\"Processing batch {i + 1}, batch shape: {data_batch.shape}\")\n", + " \n", + " # Get the model predictions\n", + " predictions = loaded_model.predict(data_batch)\n", + "\n", + " # Extend the lists to store data from each batch\n", + " all_images.extend(data_batch.numpy()) # Store all images\n", + " all_true_midpoints.extend(midpoints_batch.numpy()) # Store all true midpoints\n", + " all_pred_midpoints.extend(predictions) # Store all predicted midpoints\n", + "\n", + "# Convert lists to arrays for easier indexing\n", + "all_images = np.array(all_images)\n", + "all_true_midpoints = np.array(all_true_midpoints)\n", + "all_pred_midpoints = np.array(all_pred_midpoints)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(800, 1, 5, 2)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predictions.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Select an index to visualize from the entire dataset\n", + "index_to_visualize = np.random.randint(0, len(all_images))\n", + "\n", + "# index_to_visualize = 11548\n", + "# Visualize the selected image with predicted and true midpoints\n", + "visualize_midpoints(all_images[index_to_visualize], all_pred_midpoints[index_to_visualize, 0, :, :] * 64, title=\"Predicted Midpoints\")\n", + "visualize_midpoints(all_images[index_to_visualize], all_true_midpoints[index_to_visualize, 0, :, :] * 64, title=\"Ground Truth Midpoints\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "code to visualize Josh's edit" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "# model_builder.model.save('/home/da886/Electron Counting Extended Arch/Overfitted weights/increased_model_Padded_weights.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 268, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 193ms/step - loss: 0.0136\n" + ] + } + ], + "source": [ + "val_loss = model_builder.model.evaluate(val_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Initialize variables to track the min and max MSE\n", + "min_mse = float('inf')\n", + "max_mse = float('-inf')\n", + "min_mse_index = -1\n", + "max_mse_index = -1\n", + "\n", + "# Loop through each prediction to calculate the MSE\n", + "for i in range(len(all_pred_midpoints)):\n", + " mse = np.mean((all_pred_midpoints[i] - all_true_midpoints[i]) ** 2)\n", + " \n", + " if mse < min_mse:\n", + " min_mse = mse\n", + " min_mse_index = i\n", + " \n", + " if mse > max_mse:\n", + " max_mse = mse\n", + " max_mse_index = i\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Function to plot an image with its centers\n", + "def plot_image_with_centers(image, true_center, predicted_center, title):\n", + " plt.figure(figsize=(5, 5))\n", + " plt.imshow(image.squeeze(), cmap='gray') # Display the image\n", + "\n", + " # Plot the actual center (Groundtruth)\n", + " plt.scatter(true_center[:, 0], true_center[:, 1], color='green', label='Groundtruth', s=10)\n", + "\n", + " # Plot the predicted center\n", + " plt.scatter(predicted_center[:, 0], predicted_center[:, 1], color='red', label='Predictions', s=10)\n", + "\n", + " plt.title(title)\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# Plotting the image with the least MSE\n", + "plot_image_with_centers(all_images[min_mse_index],\n", + " all_true_midpoints[min_mse_index][0] * 64, # Adjust for scaling if needed\n", + " all_pred_midpoints[min_mse_index][0] * 64, # Adjust for scaling if needed\n", + " f'Image with Least MSE. MSE: {min_mse:.4f}')\n", + "\n", + "# Plotting the image with the largest MSE\n", + "plot_image_with_centers(all_images[max_mse_index],\n", + " all_true_midpoints[max_mse_index][0] * 64, # Adjust for scaling if needed\n", + " all_pred_midpoints[max_mse_index][0] * 64, # Adjust for scaling if needed\n", + " f'Image with Largest MSE. MSE: {max_mse:.4f}')\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/All notebooks for Tiles/Tiling images High Res copy.ipynb b/All notebooks for Tiles/Tiling images High Res copy.ipynb new file mode 100644 index 0000000..8bddc08 --- /dev/null +++ b/All notebooks for Tiles/Tiling images High Res copy.ipynb @@ -0,0 +1,2265 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:26:59.410115: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-11 22:26:59.422897: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-11 22:26:59.435701: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-11 22:26:59.439554: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-11 22:26:59.450647: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-11 22:27:00.077392: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:27:01.607391: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 78221 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-11 22:27:01.608928: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79070 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-11 22:27:01.610258: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import h5py\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " return images, centers\n", + "\n", + " def sort_centers(self, centers):\n", + " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [hits_per_tile[i] for i in range(len(tiles))]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " \"\"\"\n", + " Pads or truncates the hit coordinates for each tile to a fixed size (max_hits_per_tile).\n", + " \"\"\"\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + " return np.array(padded_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + "\n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_centers = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_centers, train_size=train_size, random_state=random_state)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/20KFixed_Mixed_5_32by32_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_377777/1698765166.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + "\n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images and centers\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile * 2) # Flatten hit locations\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "# Flatten the training and validation datasets\n", + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "val_images_flat, val_centers_flat = flatten_dataset(val_images, val_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Create TensorFlow datasets from the flattened data\n", + "batch_size = 1000\n", + "train_dataset_flat = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "val_dataset_flat = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0, 1.0, 0.875, 0.875)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(train_images), np.max(val_images), np.max(train_midpoints), np.max(val_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 0.0, 0.0, 0.0)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(train_images), np.min(val_images), np.min(train_midpoints), np.min(val_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_tiles_and_centers(data_loader, img_idx=0):\n", + " \"\"\"\n", + " Visualizes an image alongside its corresponding tiles with hit centers overlaid.\n", + "\n", + " Parameters:\n", + " - data_loader: DataLoader, the instance of DataLoader to access image and center data.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " \"\"\"\n", + " # Get the image and corresponding centers\n", + " image = data_loader.images[img_idx]\n", + " centers = data_loader.centers[img_idx]\n", + " \n", + " # Tile the image and map the centers to the tiles\n", + " tiles, hits_per_tile = data_loader.map_hits_to_tiles(image, centers)\n", + " num_tiles_per_row = int(image.shape[0] / data_loader.tile_size) # Assuming square grid of tiles\n", + "\n", + " # Create a figure grid for the original image and its tiles\n", + " fig, axs = plt.subplots(num_tiles_per_row + 1, num_tiles_per_row, figsize=(12, 12))\n", + " fig.suptitle(\"Original Image and Tiles with Hit Centers\", fontsize=16)\n", + "\n", + " # Display the original image with centers\n", + " axs[0, 0].imshow(image, cmap='gray')\n", + " axs[0, 0].set_title(\"Original Image\")\n", + " axs[0, 0].axis('off')\n", + " for (_, x, y) in centers:\n", + " axs[0, 0].scatter(x, y, color='red', marker='x') # Plot hit centers on original image\n", + "\n", + " # Hide unused axes in the first row, if any\n", + " for j in range(1, num_tiles_per_row):\n", + " axs[0, j].axis('off')\n", + "\n", + " # Plot each tile with centers marked\n", + " for idx, tile in enumerate(tiles):\n", + " row = idx // num_tiles_per_row + 1\n", + " col = idx % num_tiles_per_row\n", + " axs[row, col].imshow(tile, cmap='gray')\n", + " axs[row, col].set_title(f\"Tile {idx}\")\n", + " axs[row, col].axis('on')\n", + " \n", + " # Plot centers within the tile\n", + " for (x, y) in hits_per_tile[idx]:\n", + " axs[row, col].scatter(x, y, color='red', marker='x') # Mark center within tile coordinates\n", + "\n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.9) # Adjust spacing to fit title\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "h = np.random.randint(0, 10000)\n", + "# Call the function with your DataLoader instance\n", + "visualize_image_with_tiles_and_centers(data_loader, img_idx=h) # Visualize the first image with centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n", + "2024-11-11 22:28:37.882404: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-11 22:28:37.910616: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-11 22:28:37.945299: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731364117.991466 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364117.991466 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.006619 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053070 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053130 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053152 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053623 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053721 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053799 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.059094 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.059094 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.059201 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.075334 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.075404 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.075455 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.077613 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.077623 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.077751 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078402 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078403 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078567 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078868 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078937 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.079148 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.081256 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.081268 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.081397 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098258 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098387 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098589 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098742 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098850 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099225 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099261 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099361 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099664 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099879 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099891 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100092 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100257 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100520 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100527 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100678 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100853 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.101138 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.102521 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.102531 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.102661 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.104530 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.104532 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.104669 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.106943 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.107134 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.107265 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.109725 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.109769 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.109899 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.112007 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.112124 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.112161 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.113868 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.113911 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.114068 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.114196 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.115327 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.115346 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.115539 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.122152 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.122188 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.122312 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.124125 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.124296 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.124331 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.204811 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205157 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205367 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205424 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205627 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205898 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206079 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206257 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206447 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206486 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206667 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206965 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207096 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207193 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207415 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207625 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207638 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208066 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208139 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208374 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208422 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208597 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208977 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208994 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.209138 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.209360 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.209703 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.209907 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.210012 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.210470 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.210602 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.210810 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211035 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211260 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211327 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211541 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211827 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211853 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.212007 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.212203 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.212441 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.213040 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.213457 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.213492 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.213565 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.214718 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.214739 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.214817 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215298 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215333 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215538 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215838 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215874 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216084 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216365 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216384 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216540 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216840 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216849 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217115 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217362 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217416 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217679 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217914 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217951 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.218048 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.218280 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.219774 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.219865 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220009 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220290 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220351 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220551 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220846 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220883 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220988 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.227421 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.227433 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.227527 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.227866 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228070 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228116 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228417 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228650 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228662 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.229036 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.229476 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.229493 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 8/128\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 0.0164 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731364118.456302 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.456347 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.457726 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.457859 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.458066 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.458213 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.459979 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460048 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460377 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460473 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460847 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460920 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.463327 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.463421 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.463632 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.463733 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.466365 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.466381 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.471197 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.472341 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.472680 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.472854 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.472939 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.473211 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.473367 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.473805 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.473824 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474028 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474349 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474370 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474576 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474870 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474902 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.475453 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.475586 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.475822 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.477226 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.477243 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.477259 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.478655 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.478886 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.478941 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.479154 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.479342 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.479480 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.479706 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480046 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480054 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480267 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480500 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480680 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480991 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481009 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481577 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481637 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481774 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481992 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.482110 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.482342 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.482986 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.483331 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.483539 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.483547 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.484011 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.484803 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485080 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485171 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485485 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485797 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485876 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486205 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486334 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486417 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486567 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486828 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.487177 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.487244 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.487523 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.488304 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.488476 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.488490 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.518538 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.518967 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.519557 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.520754 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.520773 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.520791 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.522396 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.522468 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.522479 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.524479 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.524554 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.524611 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525173 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525248 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525265 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525719 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525800 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525813 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.527736 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.527754 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.527833 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529241 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529240 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529260 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529879 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529946 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529959 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.530836 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.530855 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.530933 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.532903 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.532904 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.532922 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.533866 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.533949 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.533960 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.534781 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.534859 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.534869 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.536368 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.536475 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.536555 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.537281 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.537310 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.537388 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556261 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556324 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556393 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556838 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556848 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557058 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557256 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557305 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557526 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557707 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557764 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557986 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.558184 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.558232 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.558343 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.559379 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.559456 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.559467 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561247 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561321 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561333 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561795 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561889 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561904 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.562270 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.562564 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.562597 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.562740 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563167 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563272 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563290 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563551 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563820 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563830 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.564278 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.564290 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.569388 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.569470 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.569480 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570131 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570271 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570380 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570685 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570784 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571019 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571279 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571302 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571414 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571778 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571987 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571997 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.572225 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.572644 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.572655 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.572872 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.573512 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.573523 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m126/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 0.0085" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:39.606965: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-11 22:28:39.607047: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-11 22:28:39.607202: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731364119.992246 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.992278 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.992735 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.997247 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.997334 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.997348 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.997694 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998027 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998093 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998261 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998550 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998744 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998890 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999053 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999407 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999482 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999714 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999893 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.000014 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.000461 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.000493 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.000571 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001063 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001083 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001201 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001767 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001772 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001791 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.002419 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.002426 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.002465 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.002908 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003034 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003129 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003455 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003602 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003734 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004082 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004217 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004341 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004663 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004735 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004856 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.005240 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.005348 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 14ms/step - loss: 0.0084 - val_loss: 0.0020\n", + "Epoch 2/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:40.389731: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m122/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 0.0016" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:41.652768: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 0.0016 - val_loss: 0.0012\n", + "Epoch 3/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 0.0011 - val_loss: 9.9566e-04\n", + "Epoch 4/50\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m17s\u001b[0m 137ms/step - loss: 0.0014" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:43.077966: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 9.1517e-04 - val_loss: 9.2282e-04\n", + "Epoch 5/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 8.4224e-04 - val_loss: 8.8962e-04\n", + "Epoch 6/50\n", + "\u001b[1m122/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.9947e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:46.934348: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 7.9850e-04 - val_loss: 8.6625e-04\n", + "Epoch 7/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 7.6558e-04 - val_loss: 8.4494e-04\n", + "Epoch 8/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 7.3690e-04 - val_loss: 8.2635e-04\n", + "Epoch 9/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 7.0954e-04 - val_loss: 8.1297e-04\n", + "Epoch 10/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 6.8438e-04 - val_loss: 7.9440e-04\n", + "Epoch 11/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 6.6196e-04 - val_loss: 7.8117e-04\n", + "Epoch 12/50\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m17s\u001b[0m 139ms/step - loss: 8.1208e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:53.370095: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 6.4179e-04 - val_loss: 7.7241e-04\n", + "Epoch 13/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 6.2463e-04 - val_loss: 7.6190e-04\n", + "Epoch 14/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 6.0991e-04 - val_loss: 7.5480e-04\n", + "Epoch 15/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.9718e-04 - val_loss: 7.5351e-04\n", + "Epoch 16/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.8630e-04 - val_loss: 7.5459e-04\n", + "Epoch 17/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.7694e-04 - val_loss: 7.5569e-04\n", + "Epoch 18/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.6865e-04 - val_loss: 7.5895e-04\n", + "Epoch 19/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.5979e-04 - val_loss: 7.6116e-04\n", + "Epoch 20/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.5267e-04 - val_loss: 7.6509e-04\n", + "Epoch 21/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.4572e-04 - val_loss: 7.6805e-04\n", + "Epoch 22/50\n", + "\u001b[1m124/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 6ms/step - loss: 5.3867e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:29:07.534414: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.3858e-04 - val_loss: 7.7136e-04\n", + "Epoch 23/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.3156e-04 - val_loss: 7.7555e-04\n", + "Epoch 24/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.2507e-04 - val_loss: 7.7657e-04\n", + "Epoch 25/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.1843e-04 - val_loss: 7.8298e-04\n", + "Epoch 26/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.1206e-04 - val_loss: 7.8483e-04\n", + "Epoch 27/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.0663e-04 - val_loss: 7.9219e-04\n", + "Epoch 28/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.9985e-04 - val_loss: 7.9633e-04\n", + "Epoch 29/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.9338e-04 - val_loss: 8.0354e-04\n", + "Epoch 30/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.8780e-04 - val_loss: 8.1546e-04\n", + "Epoch 31/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.8193e-04 - val_loss: 8.2067e-04\n", + "Epoch 32/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.7664e-04 - val_loss: 8.2672e-04\n", + "Epoch 33/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 9ms/step - loss: 4.7026e-04 - val_loss: 8.3414e-04\n", + "Epoch 34/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.6551e-04 - val_loss: 8.4403e-04\n", + "Epoch 35/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.5926e-04 - val_loss: 8.4788e-04\n", + "Epoch 36/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.5397e-04 - val_loss: 8.5360e-04\n", + "Epoch 37/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.4883e-04 - val_loss: 8.6109e-04\n", + "Epoch 38/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 4.4539e-04 - val_loss: 8.6610e-04\n", + "Epoch 39/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.3821e-04 - val_loss: 8.7378e-04\n", + "Epoch 40/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.3356e-04 - val_loss: 8.8890e-04\n", + "Epoch 41/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 4.2916e-04 - val_loss: 8.8778e-04\n", + "Epoch 42/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.2336e-04 - val_loss: 8.9218e-04\n", + "Epoch 43/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.1905e-04 - val_loss: 9.0233e-04\n", + "Epoch 44/50\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m18s\u001b[0m 142ms/step - loss: 3.3601e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:29:36.141124: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.1469e-04 - val_loss: 9.1067e-04\n", + "Epoch 45/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 4.1099e-04 - val_loss: 9.1877e-04\n", + "Epoch 46/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 4.0566e-04 - val_loss: 9.2916e-04\n", + "Epoch 47/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.0140e-04 - val_loss: 9.3635e-04\n", + "Epoch 48/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 3.9789e-04 - val_loss: 9.4423e-04\n", + "Epoch 49/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 3.9460e-04 - val_loss: 9.5438e-04\n", + "Epoch 50/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 3.9048e-04 - val_loss: 9.6507e-04\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "\n", + "# Define the model\n", + "def create_model(input_shape=(8, 8, 1), max_hits=5):\n", + " model = tf.keras.Sequential([\n", + " tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + " tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(128, activation='relu'),\n", + " tf.keras.layers.Dense(max_hits * 2) # Predict x and y for each hit, so output shape is (max_hits * 2,)\n", + " ])\n", + " return model\n", + "with strategy.scope():\n", + " # Create an instance of the model\n", + " model = create_model()\n", + "\n", + " # Compile the model\n", + " model.compile(optimizer='adam', loss='mse')\n", + "\n", + "# Train the model\n", + "history = model.fit(\n", + " train_dataset_flat, # Dataset prepared in your previous code\n", + " validation_data=val_dataset_flat,\n", + " epochs=50,\n", + " batch_size=1000\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot sample tiles and hit locations\n", + "v = np.random.randint(0, len(data_loader.images))\n", + "tiles, hits_per_tile = data_loader.map_hits_to_tiles(data_loader.images[v], data_loader.centers[v])\n", + "\n", + "fig, axs = plt.subplots(4, 4, figsize=(12, 12))\n", + "for i, ax in enumerate(axs.flat):\n", + " tile = tiles[i]\n", + " hits = hits_per_tile[i]\n", + " \n", + " ax.imshow(tile, cmap='gray')\n", + " for (x, y) in hits:\n", + " ax.scatter(x, y, c='red', marker='x')\n", + " ax.axis('on')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + "# # Reshape reference_point to match the shape of midpoints for broadcasting\n", + "# reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + "# reference_point = tf.reshape(reference_point, (1, 1, 2)) # Shape (1, 1, 2)\n", + " \n", + "# # Reshape midpoints to (batch_size, num_hits, 2) for sorting\n", + "# midpoints = tf.reshape(midpoints, (-1, 5, 2)) # Assuming 5 hits per image\n", + " \n", + "# # Calculate Euclidean distances from the reference point\n", + "# distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_hits)\n", + " \n", + "# # Get sorted indices based on distances\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + "# # Gather sorted midpoints\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# # Define the reference point\n", + "# reference_point = (0.0, 0.0)\n", + " \n", + "# # Sort both y_true and y_pred based on distances from the reference point\n", + "# y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + "# y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + "# # Calculate Euclidean distance between sorted true and predicted midpoints\n", + "# diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss across all coordinates\n", + "# return tf.reduce_mean(powered_diff)\n", + " \n", + "# return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "# import matplotlib.pyplot as plt\n", + "# import numpy as np\n", + "# import random\n", + "\n", + "# def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + "# \"\"\"\n", + "# Reconstructs the original image from tiles.\n", + "\n", + "# Parameters:\n", + "# - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + "# - tile_size: int, the size of each tile.\n", + "# - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + "# Returns:\n", + "# - image: np.array, the reconstructed original image.\n", + "# \"\"\"\n", + "# reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + "# for idx, tile in enumerate(tiles):\n", + "# row = (idx // num_tiles_per_row) * tile_size\n", + "# col = (idx % num_tiles_per_row) * tile_size\n", + "# reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "# return reconstructed_image\n", + "\n", + "# def visualize_predictions_with_original(model, dataset, tile_size=8, max_hits_per_tile=5, num_images=1, threshold=0.1):\n", + "# \"\"\"\n", + "# Visualizes the model's predictions on a random sample of images from the dataset,\n", + "# showing both the original image and tiled predictions.\n", + "\n", + "# Parameters:\n", + "# - model: tf.keras.Model, the trained model to make predictions.\n", + "# - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + "# - tile_size: int, the size of each tile.\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "# - num_images: int, number of random images to visualize.\n", + "# - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + "# \"\"\"\n", + "# # Take one batch from the dataset for prediction\n", + "# images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + "# # Randomly select indices of images to visualize\n", + "# indices = random.sample(range(images.shape[0] // 4), num_images)\n", + "\n", + "# # Make predictions on the batch\n", + "# predictions = model.predict(images)\n", + "\n", + "# # Visualize the selected images\n", + "# for img_idx in indices:\n", + "# # Reconstruct the original image from tiles\n", + "# tiles = images[img_idx * 4 : (img_idx + 1) * 4]\n", + "# reconstructed_image = reconstruct_image_from_tiles(tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 2) # Assuming 2x2 tiles for 4 tiles per image\n", + "\n", + "# # Plot the original image with overlayed predictions\n", + "# fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + "# ax_orig.imshow(reconstructed_image, cmap='gray')\n", + "# ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + "# # Overlay true and predicted centers on the original image\n", + "# for tile_idx in range(4): # Assuming 2x2 tiles\n", + "# row_offset = (tile_idx // 2) * tile_size\n", + "# col_offset = (tile_idx % 2) * tile_size\n", + "\n", + "# # Get true and predicted centers for each tile\n", + "# true_tile_centers = true_centers[img_idx * 4 + tile_idx].numpy().reshape(-1, 2)\n", + "# predicted_tile_centers = predictions[img_idx * 4 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + "# # Plot true hits in green\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot predicted hits in red, with threshold check\n", + "# for (x, y) in predicted_tile_centers:\n", + "# # Ignore (0, 0) or predictions close to it\n", + "# if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Add legend\n", + "# handles, labels = ax_orig.get_legend_handles_labels()\n", + "# ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + "# # Now plot the tiled images with predictions\n", + "# fig, axs = plt.subplots(4, 4, figsize=(6, 6))\n", + "# fig.suptitle(f\"Tiled Predictions (Image {img_idx})\")\n", + "\n", + "# for tile_idx, ax in enumerate(axs.flat):\n", + "# true_tile_centers = true_centers[img_idx * 4 + tile_idx].numpy().reshape(-1, 2)\n", + "# predicted_tile_centers = predictions[img_idx * 4 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + "# # Display the tile\n", + "# ax.imshow(images[img_idx * 4 + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + "# # Plot true centers\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot predicted centers with threshold check\n", + "# for (x, y) in predicted_tile_centers:\n", + "# # Ignore (0, 0) or predictions close to it\n", + "# if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + "# ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# ax.axis('off')\n", + "\n", + "# handles, labels = axs[0, 0].get_legend_handles_labels()\n", + "# fig.legend(handles, labels, loc='upper right')\n", + "# plt.tight_layout()\n", + "# plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # Example usage\n", + "# visualize_predictions_with_original(model, val_dataset_flat, tile_size=8, max_hits_per_tile=5, num_images=2, threshold=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import random\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " return reconstructed_image\n", + "\n", + "def aggregate_predictions_across_tiles(predicted_hits, max_hits=5):\n", + " \"\"\"\n", + " Aggregates predicted hits across all tiles in the parent image and limits\n", + " to a maximum of `max_hits`.\n", + "\n", + " Parameters:\n", + " - predicted_hits: list of tuples with (x, y) coordinates of predicted hits.\n", + " - max_hits: int, maximum number of hits allowed per parent image.\n", + "\n", + " Returns:\n", + " - aggregated_hits: list of tuples with (x, y) coordinates limited to max_hits.\n", + " \"\"\"\n", + " # Sort by distance from origin (or by another criteria if available) and pick top `max_hits`\n", + " # Here we just truncate for simplicity; in practice, use model-provided confidence if available.\n", + " if len(predicted_hits) > max_hits:\n", + " return predicted_hits[:max_hits]\n", + " return predicted_hits\n", + "\n", + "def visualize_predictions_with_constraints(model, dataset, tile_size=8, max_hits_per_image=5, num_images=1, threshold=0.1):\n", + " \"\"\"\n", + " Visualizes the model's predictions on a random sample of images from the dataset,\n", + " showing both the original image and tiled predictions.\n", + "\n", + " Parameters:\n", + " - model: tf.keras.Model, the trained model to make predictions.\n", + " - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_image: int, maximum number of hits allowed per parent image.\n", + " - num_images: int, number of random images to visualize.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \"\"\"\n", + " images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + " indices = random.sample(range(images.shape[0] // 16), num_images)\n", + " predictions = model.predict(images)\n", + "\n", + " for img_idx in indices:\n", + " tiles = images[img_idx * 16 : (img_idx + 1) * 16]\n", + " reconstructed_image = reconstruct_image_from_tiles(tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 4)\n", + "\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + " all_predicted_hits = []\n", + "\n", + " for tile_idx in range(16): # 4x4 grid\n", + " row_offset = (tile_idx // 4) * tile_size\n", + " col_offset = (tile_idx % 4) * tile_size\n", + "\n", + " true_tile_centers = true_centers[img_idx * 16 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 16 + tile_idx].reshape(5, 2) # Assuming 5 predictions max per tile\n", + "\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + " all_predicted_hits.append((col_offset + x * tile_size, row_offset + y * tile_size))\n", + "\n", + " limited_predicted_hits = aggregate_predictions_across_tiles(all_predicted_hits, max_hits=max_hits_per_image)\n", + "\n", + " for (x, y) in limited_predicted_hits:\n", + " ax_orig.scatter(x, y, c='red', marker='o', s=30, label='Predicted Hit' if x == limited_predicted_hits[0][0] else \"\")\n", + "\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + " fig, axs = plt.subplots(4, 4, figsize=(8, 8))\n", + " fig.suptitle(f\"Tiled Predictions (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " true_tile_centers = true_centers[img_idx * 16 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 16 + tile_idx].reshape(5, 2)\n", + "\n", + " ax.imshow(images[img_idx * 16 + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0):\n", + " ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " ax.axis('off')\n", + "\n", + " handles, labels = axs[0, 0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage\n", + "visualize_predictions_with_constraints(model, val_dataset_flat, tile_size=8, max_hits_per_image=5, num_images=1, threshold=0.1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers_flat[43]" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((128000, 8, 8, 1), (128000, 10))" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images_flat.shape, train_centers_flat.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"sequential\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 32)       │           320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 32)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        18,496 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 10)             │         1,290 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m1,290\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 85,280 (333.13 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m85,280\u001b[0m (333.13 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 28,426 (111.04 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m28,426\u001b[0m (111.04 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Optimizer params: 56,854 (222.09 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m56,854\u001b[0m (222.09 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tiled images shape: (10000, 16, 8, 8)\n", + "Tiled centers shape: (10000, 16)\n", + "Flattened train images shape: (128000, 8, 8, 1)\n", + "Flattened train centers shape: (128000, 10)\n", + "Sample flattened image tile: [[0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]]\n", + "Sample flattened centers: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "Epoch 1/5\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m16s\u001b[0m 131ms/step - loss: 2.9621e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_377777/1698765166.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 15ms/step - loss: 3.8614e-04 - val_loss: 9.6683e-04\n", + "Epoch 2/5\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 3.8246e-04 - val_loss: 9.7807e-04\n", + "Epoch 3/5\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 3.8066e-04 - val_loss: 9.8486e-04\n", + "Epoch 4/5\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 3.7556e-04 - val_loss: 9.9021e-04\n", + "Epoch 5/5\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 3.7251e-04 - val_loss: 0.0010\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 168ms/step\n", + "Predicted hit centers for sample validation tiles: [[ 3.87402996e-03 1.10752136e-03 -2.85455212e-03 -2.44698487e-04\n", + " -1.07228756e-04 1.69471279e-03 -1.39096286e-04 -1.06428721e-04\n", + " 2.21667811e-04 -6.67363405e-04]\n", + " [ 3.87402996e-03 1.10752136e-03 -2.85455212e-03 -2.44698487e-04\n", + " -1.07228756e-04 1.69471279e-03 -1.39096286e-04 -1.06428721e-04\n", + " 2.21667811e-04 -6.67363405e-04]\n", + " [ 4.94345486e-01 2.54629374e-01 9.77038406e-03 -8.84084310e-03\n", + " -5.95828518e-04 3.74388508e-03 5.12754079e-04 -5.72215999e-04\n", + " 1.24042947e-03 -3.46343964e-03]\n", + " [ 3.87402996e-03 1.10752136e-03 -2.85455212e-03 -2.44698487e-04\n", + " -1.07228756e-04 1.69471279e-03 -1.39096286e-04 -1.06428721e-04\n", + " 2.21667811e-04 -6.67363405e-04]\n", + " [ 2.42476597e-01 8.81621122e-01 1.15823690e-02 -1.12887248e-02\n", + " -2.11387873e-04 1.16765499e-03 4.10967134e-03 1.74771983e-03\n", + " 1.59845210e-03 -1.26217981e-03]\n", + " [ 2.55703926e-05 -8.60796776e-04 3.18645127e-03 6.16440922e-03\n", + " -2.49969959e-03 -1.05984509e-05 4.86701727e-04 -3.12706339e-04\n", + " -1.15513394e-05 -1.47292158e-04]\n", + " [ 2.55703926e-05 -8.60796776e-04 3.18645127e-03 6.16440922e-03\n", + " -2.49969959e-03 -1.05984509e-05 4.86701727e-04 -3.12706339e-04\n", + " -1.15513394e-05 -1.47292158e-04]\n", + " [ 2.55703926e-05 -8.60796776e-04 3.18645127e-03 6.16440922e-03\n", + " -2.49969959e-03 -1.05984509e-05 4.86701727e-04 -3.12706339e-04\n", + " -1.15513394e-05 -1.47292158e-04]\n", + " [ 2.20222771e-03 -1.25420187e-03 2.15841085e-03 2.34137475e-03\n", + " -1.31809153e-04 -7.01203942e-04 -6.89302571e-04 3.71206552e-05\n", + " 2.85808463e-04 4.54799854e-04]\n", + " [ 2.20222771e-03 -1.25420187e-03 2.15841085e-03 2.34137475e-03\n", + " -1.31809153e-04 -7.01203942e-04 -6.89302571e-04 3.71206552e-05\n", + " 2.85808463e-04 4.54799854e-04]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731366052.222467 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223012 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223257 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223499 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223719 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223937 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.224165 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.224378 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.224753 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.224968 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.225186 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.225397 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.225609 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.225826 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226051 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226282 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226479 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226707 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226926 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.227148 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.227380 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.227620 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.227856 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.228215 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.228442 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.231589 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.232028 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.232355 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.232658 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.232933 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.233213 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.233526 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.233801 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.234237 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.234528 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.234826 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.235100 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.235373 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.235666 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.235963 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.236267 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.236525 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.236821 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.237118 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.237427 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.237735 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.238048 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.238371 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.238817 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.239120 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + } + ], + "source": [ + "# Checkpoint after tiling\n", + "tiled_images, tiled_centers = data_loader.process_data()\n", + "print(\"Tiled images shape:\", tiled_images.shape) # Expected: (num_images, num_tiles, tile_size, tile_size)\n", + "print(\"Tiled centers shape:\", tiled_centers.shape) # Expected: (num_images, num_tiles, max_hits_per_tile, 2)\n", + "\n", + "# Checkpoint after flattening\n", + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "print(\"Flattened train images shape:\", train_images_flat.shape) # Expected: (num_images * num_tiles, tile_size, tile_size, 1)\n", + "print(\"Flattened train centers shape:\", train_centers_flat.shape) # Expected: (num_images * num_tiles, max_hits_per_tile * 2)\n", + "\n", + "# Check specific samples to ensure values match expectations\n", + "print(\"Sample flattened image tile:\", train_images_flat[0].reshape(8, 8)) # Reshape to view as 8x8\n", + "print(\"Sample flattened centers:\", train_centers_flat[0]) # Should have 10 elements, representing 5 (x, y) pairs\n", + "\n", + "# Train and evaluate the model with checkpoints in place to validate output\n", + "history = model.fit(\n", + " train_dataset_flat,\n", + " validation_data=val_dataset_flat,\n", + " epochs=5, # Reduced for debugging; increase once everything is confirmed to work\n", + " batch_size=batch_size\n", + ")\n", + "\n", + "# After training, visualize a sample of predictions to validate model behavior\n", + "predictions = model.predict(val_images_flat[:10]) # Predict on a small batch\n", + "print(\"Predicted hit centers for sample validation tiles:\", predictions)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sample tiled images for the first image: [[[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 89 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " ...\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]]\n", + "Sample tiled centers for the first image: [list([]) list([(6.0, 2.0), (4.0, 1.0)]) list([]) list([])\n", + " list([(1.0, 5.0)]) list([]) list([]) list([(1.0, 4.0)])\n", + " list([(5.0, 2.0)]) list([]) list([]) list([]) list([]) list([]) list([])\n", + " list([])]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_377777/1698765166.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "# After tiling and mapping hits\n", + "tiled_images, tiled_centers = data_loader.process_data()\n", + "\n", + "# Inspect a sample image and its tiles\n", + "print(\"Sample tiled images for the first image:\", tiled_images[0])\n", + "print(\"Sample tiled centers for the first image:\", tiled_centers[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processed tiled images shape: (10000, 16, 8, 8)\n", + "Processed tiled centers shape: (10000, 16, 5, 2)\n", + "Sample tiled images for the first image: [[[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 89 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " ...\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]]\n", + "Sample tiled centers for the first image: [[[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[6. 2.]\n", + " [4. 1.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[1. 5.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[1. 4.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[5. 2.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " # Pad or truncate hits for each tile to ensure consistent length\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # Convert to NumPy arrays with fixed dimensions\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/20KFixed_Mixed_5_32by32_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Process the data and check the results\n", + "tiled_images, tiled_centers = data_loader.process_data()\n", + "print(\"Processed tiled images shape:\", tiled_images.shape) # Should be (num_images, num_tiles, tile_size, tile_size)\n", + "print(\"Processed tiled centers shape:\", tiled_centers.shape) # Should be (num_images, num_tiles, max_hits_per_tile, 2)\n", + "\n", + "# Visualize the first image's tiles and centers\n", + "print(\"Sample tiled images for the first image:\", tiled_images[0])\n", + "print(\"Sample tiled centers for the first image:\", tiled_centers[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " \n", + " # Normalize image data to [0, 1]\n", + " normalized_images = tiled_images / 255.0 # Assuming the pixel values are in the 0-255 range\n", + " \n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " return normalized_images, np.array(padded_centers)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + " \n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and pad if necessary\n", + " flat_centers = []\n", + " for img_centers in centers:\n", + " for tile_centers in img_centers:\n", + " # Convert tile_centers to a list of tuples to handle padding consistently\n", + " tile_centers = list(tile_centers)\n", + " if len(tile_centers) == 0:\n", + " tile_centers = [(0, 0)] * max_hits_per_tile\n", + " else:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " tile_centers = tile_centers[:max_hits_per_tile] + [(0, 0)] * (max_hits_per_tile - len(tile_centers))\n", + "\n", + " # Flatten each (x, y) hit into a single list\n", + " flat_centers.append([coord for hit in tile_centers for coord in hit])\n", + "\n", + " flat_centers = np.array(flat_centers)\n", + " return flat_images, flat_centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Flattened train images shape: (128000, 8, 8, 1)\n", + "Flattened train centers shape: (128000, 10)\n", + "Sample flattened centers after normalization: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n" + ] + } + ], + "source": [ + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "print(\"Flattened train images shape:\", train_images_flat.shape) # Expected (128000, 8, 8, 1)\n", + "print(\"Flattened train centers shape:\", train_centers_flat.shape) # Expected (128000, 10)\n", + "print(\"Sample flattened centers after normalization:\", train_centers_flat[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 10 samples of flattened centers: [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0.125 0.75 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0.75 0.875 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0.25 0. 0. 0. 0. 0. 0. 0. 0. 0. ]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " \n", + " # Debug: Print the raw centers before any processing\n", + " print(\"Raw centers for first image:\", centers[0])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " # Debug: Print hits mapped to tiles for the first image\n", + " print(\"Mapped hits per tile for first image:\", hits_per_tile)\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # Debug: Check tiled centers before normalization and padding\n", + " print(\"Tiled centers for the first image before padding:\", tiled_centers[0])\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + "\n", + " # Debug: Print padded centers for the first image\n", + " print(\"Padded centers for the first image:\", padded_centers[0])\n", + " return np.array(padded_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / 255.0 # Assuming image values are in 0-255\n", + "\n", + " # Normalize centers by scaling coordinates to the tile size and apply padding\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " # Debug: Check normalized and padded centers for the first image\n", + " print(\"Normalized and padded centers for the first image:\", padded_centers[0])\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + "# Instantiate DataLoader and inspect each step\n", + "file_path = '/path/to/your/h5file.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Run data processing and normalization\n", + "normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# Flatten the dataset and inspect the output\n", + "train_images_flat, train_centers_flat = flatten_dataset(normalized_images, normalized_centers, tile_size=8, max_hits_per_tile=5)\n", + "print(\"Sample flattened centers:\", train_centers_flat[:10])\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/All notebooks for Tiles/Tiling images High Res .ipynb b/All notebooks for Tiles/Tiling images High Res .ipynb new file mode 100644 index 0000000..af4f383 --- /dev/null +++ b/All notebooks for Tiles/Tiling images High Res .ipynb @@ -0,0 +1,3588 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:03:33.724853: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-11 17:03:33.737701: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-11 17:03:33.750583: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-11 17:03:33.754422: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-11 17:03:33.765497: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-11 17:03:34.392029: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:03:38.921991: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 78643 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-11 17:03:38.923528: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79070 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-11 17:03:38.924872: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_105982/3913266335.py:64: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Images Shape: (16000, 16, 16, 16)\n", + "Validation Images Shape: (4000, 16, 16, 16)\n" + ] + } + ], + "source": [ + "# Import necessary libraries\n", + "import numpy as np\n", + "import h5py\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "from tensorflow.keras import layers, Model\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "tf.random.set_seed(42)\n", + "\n", + "# Define the DataLoader class\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=16, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + " \n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:20000])\n", + " centers = np.array(f['centers_training'][:20000])\n", + " return images, centers\n", + " \n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + " \n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + " \n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + " \n", + " local_x = (x % self.tile_size)\n", + " local_y = (y % self.tile_size)\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + " \n", + " return tiles, hits_per_tile\n", + " \n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + " \n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + " \n", + " tile_hits_list = [hits_per_tile[i] for i in range(len(tiles))]\n", + " tiled_centers.append(tile_hits_list)\n", + " \n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + " \n", + " def pad_hits(self, centers):\n", + " \"\"\"\n", + " Pads or truncates the hit coordinates for each tile to a fixed size (max_hits_per_tile).\n", + " \"\"\"\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + " return np.array(padded_centers)\n", + " \n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " # Ensure data type is float32 for TensorFlow compatibility\n", + " tiled_images = tiled_images.astype('float32')\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + " \n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + " \n", + " return normalized_images, np.array(padded_centers, dtype='float32')\n", + " \n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_centers = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_centers, train_size=train_size, random_state=random_state)\n", + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "tile_size = 16\n", + "max_hits_per_tile = 5\n", + "\n", + "data_loader = DataLoader(file_path, tile_size=tile_size, max_hits_per_tile=max_hits_per_tile)\n", + "\n", + "# Split the data\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "# Verify data shapes\n", + "print(f\"Train Images Shape: {train_images.shape}\") # Expected: (train_samples, num_tiles, 16, 16)\n", + "print(f\"Validation Images Shape: {val_images.shape}\")\n", + "\n", + "# Create TensorFlow datasets for training and validation\n", + "batch_size = 1000\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", + "\n", + "train_dataset = train_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=True).batch(batch_size)\n", + "val_dataset = val_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=False).batch(batch_size)\n", + "\n", + "\n", + "\n", + "def build_fixed_hits_model_with_confidence(input_shape=(16, 16, 1), num_hits=5):\n", + " output_units = num_hits * 3 # 2 coordinates + 1 confidence score for each hit\n", + " \n", + " inputs = layers.Input(shape=input_shape)\n", + " \n", + " # Convolutional layers\n", + " x = layers.Conv2D(128, (5, 5), activation='relu', padding='same')(inputs)\n", + " x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)\n", + " x = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(x)\n", + " \n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " \n", + " # Fully connected layers\n", + " x = layers.Flatten()(x)\n", + " x = layers.Dense(64, activation='relu')(x)\n", + " \n", + " # Output layer with coordinates and confidence scores\n", + " coordinates_confidence_output = layers.Dense(output_units, activation='sigmoid', name='coordinates_confidence_output')(x)\n", + " reshaped_output = layers.Reshape((num_hits, 3), name='coordinates_confidence_output_reshaped')(coordinates_confidence_output)\n", + " \n", + " model = Model(inputs, reshaped_output)\n", + " return model\n", + "\n", + "# Create the model with confidence outputs\n", + "model_with_confidence = build_fixed_hits_model_with_confidence()\n", + "\n", + "# Adjust data shapes for model input\n", + "def prepare_dataset(dataset):\n", + " def reshape_function(images, centers):\n", + " # Reshape images to (batch_size * num_tiles, tile_size, tile_size, 1)\n", + " batch_size, num_tiles, tile_h, tile_w = images.shape\n", + " images = tf.reshape(images, (-1, tile_h, tile_w, 1))\n", + " centers = tf.reshape(centers, (-1, max_hits_per_tile, 2))\n", + " return images, centers\n", + " return dataset.map(reshape_function)\n", + "\n", + "train_dataset_prepared = prepare_dataset(train_dataset)\n", + "val_dataset_prepared = prepare_dataset(val_dataset)\n", + "\n", + "\n", + "import tensorflow as tf\n", + "\n", + "def custom_loss_with_count_penalty(y_true, y_pred, desired_hits=5):\n", + " # Separate coordinates and confidence from predictions\n", + " y_pred_coords = y_pred[..., :2] # Extract only (x, y) coordinates\n", + " y_pred_confidence = y_pred[..., 2] # Extract confidence scores\n", + "\n", + " # Calculate MSE for hit locations, ignoring padded zeroes in y_true\n", + " mask = tf.not_equal(y_true, 0)\n", + " y_true_masked = tf.boolean_mask(y_true, mask)\n", + " y_pred_coords_masked = tf.boolean_mask(y_pred_coords, mask)\n", + " location_loss = tf.reduce_mean(tf.square(y_true_masked - y_pred_coords_masked))\n", + "\n", + " # Calculate the number of confident predictions per image\n", + " # Here, we use a threshold (e.g., > 0.5) to consider a hit as a confident prediction\n", + " predicted_hits_count = tf.reduce_sum(tf.cast(y_pred_confidence > 0.5, tf.float32), axis=-1)\n", + " count_penalty = tf.reduce_mean(tf.square(predicted_hits_count - desired_hits))\n", + "\n", + " # Combine losses\n", + " total_loss = location_loss + 0.1 * count_penalty # Adjust the 0.1 weight to control penalty strength\n", + " return total_loss\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_1 (InputLayer)      │ (None, 16, 16, 1)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (Conv2D)               │ (None, 16, 16, 128)    │         3,328 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_4 (Conv2D)               │ (None, 16, 16, 64)     │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_5 (Conv2D)               │ (None, 16, 16, 128)    │        73,856 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (MaxPooling2D)  │ (None, 8, 8, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (Flatten)             │ (None, 8192)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 64)             │       524,352 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ coordinates_confidence_output   │ (None, 15)             │           975 │\n",
+       "│ (Dense)                         │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ coordinates_confidence_output_… │ (None, 5, 3)           │             0 │\n",
+       "│ (Reshape)                       │                        │               │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_1 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m3,328\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_4 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_5 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8192\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m524,352\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ coordinates_confidence_output │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m15\u001b[0m) │ \u001b[38;5;34m975\u001b[0m │\n", + "│ (\u001b[38;5;33mDense\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ coordinates_confidence_output_… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 676,303 (2.58 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m676,303\u001b[0m (2.58 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 676,303 (2.58 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m676,303\u001b[0m (2.58 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:29.666793: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-11 17:04:29.679139: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-11 17:04:29.725156: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731344669.832902 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.835555 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.843248 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.896382 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.896463 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.896523 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.918493 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.918673 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.919308 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.921435 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.921861 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.922797 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.922810 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.923163 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.924076 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.935786 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.935897 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.935912 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.942943 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.943103 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.944038 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.959662 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.959769 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.959790 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.962601 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.962712 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.962742 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.964820 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.965058 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.965173 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.967374 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.967677 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.968447 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.973368 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.973488 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.973879 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.979258 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.979344 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.979714 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.983279 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.983338 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.983490 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.992026 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.993409 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.993719 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.996362 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.996923 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.997662 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.001834 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.001848 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.002093 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.011340 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.011345 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.011563 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.024452 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.024597 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.024690 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.108427 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.109327 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.109721 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.112955 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.113872 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.114239 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.117338 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.118259 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.118589 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.121859 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.122791 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.123084 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.127484 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.128414 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.128694 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.135501 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.136520 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.136716 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.146796 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.148024 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.148033 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.158100 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.159355 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.159460 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.169259 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.170427 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.170630 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.181276 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.182330 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.182652 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.202975 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.203818 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.204350 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.224625 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.225251 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.226001 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.406356 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.406772 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.408275 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.409302 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.409708 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.411234 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.412894 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.413277 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.414824 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.416131 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.416512 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.418076 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.419719 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.420096 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.421721 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.423391 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.423753 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.425404 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.428887 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.429237 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.430914 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.434989 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.435368 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.437037 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.439070 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.439396 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.441093 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.443536 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.443900 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.445606 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.450492 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.450800 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.452561 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.454920 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.455188 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.456984 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.458965 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.459206 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.461034 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.463527 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.463752 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.465484 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.471235 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.471447 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.473164 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.477447 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.477461 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.479069 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.483370 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.483465 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.484844 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.488432 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.489948 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.490286 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.493268 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.494802 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.495381 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.500225 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.508225 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.508236 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.513161 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.515273 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.515372 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.519807 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.528315 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.528329 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.532669 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.546623 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.546844 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.551087 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.568767 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.572022 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.573513 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.574676 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.575253 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.576786 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.577934 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.578988 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.580519 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.581165 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.582176 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.583748 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.584884 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.586928 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.587528 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.588030 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.592245 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.593324 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.598850 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.603560 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.604525 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.610211 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.614908 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.615765 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.621422 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.626126 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.626862 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.632449 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.637148 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.637769 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.643508 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.648211 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.648718 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.655602 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.660274 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.660674 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.822414 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.824837 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.826444 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.826553 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.827654 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.828897 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.829065 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.831110 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.831732 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.831899 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.834792 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.835184 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.835386 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.838528 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.838864 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.839063 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.842696 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.842824 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.842922 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.846483 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.846855 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.847042 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.850707 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.850911 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.851008 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.854949 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.855124 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.855418 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.859652 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.859848 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.860309 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.864524 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.864764 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.873085 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.877229 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.877653 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.878402 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.882527 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.882994 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.883566 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.887593 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.888157 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.888502 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.892489 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.893090 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.894267 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.898211 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.898847 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.900514 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.904393 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.905086 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.907489 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.911301 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.912035 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.914694 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.918441 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.919238 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.920836 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.924529 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.925366 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.933301 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.933607 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.937204 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.946068 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.946353 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.949881 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.958926 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.466921 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.466942 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.470769 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.472062 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.472140 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.474351 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.477357 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.477427 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.479495 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.482940 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.482958 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.484012 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.487490 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.487591 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.488429 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.492033 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.492220 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.492972 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.498013 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.498370 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.498432 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.502652 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.503214 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.503281 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.507410 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.508153 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.508219 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.511086 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.511993 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.512067 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.514779 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.515852 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.515917 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.520366 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.521068 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.521150 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.525650 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.526542 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.526617 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.533568 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.534675 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.534742 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.539609 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.540904 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.540971 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.546849 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.548356 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.548423 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.553362 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.555054 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.555130 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.560633 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.562525 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.562624 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.571742 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.573914 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.573978 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.582773 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.585203 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.585270 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.595337 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.597907 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.600412 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.615824 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.615851 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.616093 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.629434 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.629655 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.629837 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.796314 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.797053 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.797265 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.799943 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.800686 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.800910 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.803718 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.804893 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.805838 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.808389 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.808798 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.809636 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.812885 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.813698 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.813813 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.817470 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.818454 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.818531 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.822219 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.823391 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.823518 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.826886 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.828249 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.828327 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.831771 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.833304 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.833379 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.836917 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.838650 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.838716 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.841968 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.843959 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.843971 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.848276 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.849735 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.849803 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.853247 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.854797 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.854874 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.859303 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.861044 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.861161 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.865376 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.867316 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.867338 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.871417 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.873505 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.873574 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.880146 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.882396 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.882477 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.885888 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.888200 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.888414 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.897166 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.899494 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.900002 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.926370 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.926484 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.926970 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.932055 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.932240 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.932698 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.937980 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.938047 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.938326 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.943840 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.943933 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.944048 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.949499 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.949623 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.949721 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.955825 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.956096 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.957453 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.961902 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.963261 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.964713 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.967521 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.969061 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.970583 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.972414 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.973938 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.975418 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.977965 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.979485 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.980917 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.982764 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.984292 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.985675 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.989046 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.990585 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.991914 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.994008 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.995565 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.997109 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.002368 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.003971 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.005420 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.010672 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.012256 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.013655 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.017411 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.018957 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.020354 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.023459 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.025002 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.026353 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.028818 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.030364 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.031666 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.039861 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.041380 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.042687 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.049090 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.050586 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.051850 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.058344 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.059792 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.061014 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.068039 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.069514 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.070636 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.090472 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.092147 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.093033 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.104901 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.106118 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.106848 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.118634 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.119886 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.120445 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.132327 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.133634 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.134028 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.146035 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.147385 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.147663 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.162014 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.163483 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.163571 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.177959 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.179487 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.179585 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.196620 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.197961 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.198520 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.439482 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.442655 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.442665 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.444334 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.447623 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.447701 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.449080 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.452568 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.452586 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.453910 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.457585 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.458960 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.462246 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.465968 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.467595 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.467706 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.471046 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.472823 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.475327 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.478783 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.480347 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.480641 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.483779 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.485655 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.494733 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.498357 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.500358 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.513733 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.517071 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.519249 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.535362 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.538888 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.541229 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.552774 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.556518 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.558813 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.585285 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.588513 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.591597 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.591627 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.591792 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.594911 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.595217 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.595231 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.598045 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.598376 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.598952 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.601313 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.601652 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.602066 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.605056 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.605441 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.605541 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.608201 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.608696 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.610107 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.611428 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.611938 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.613837 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.616099 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.616628 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.618423 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.619832 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.620380 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.622205 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.624427 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.624991 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.625811 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.628212 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.628788 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.629901 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.631828 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.632423 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.634392 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.356773 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.356822 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.361548 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.361619 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.907780 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.913325 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.918499 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.918992 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.924591 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.929835 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.930142 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.935801 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.941088 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.941496 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.947217 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.516477 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.516485 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.527303 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.528092 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.528312 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.538825 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.539853 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.540294 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.550882 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.552059 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.553033 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.563610 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.564932 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.578451 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.588409 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.589720 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.726540 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.730228 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.733781 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.737202 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.737967 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.739158 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.740898 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.741690 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.742892 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.744731 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.745269 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.746488 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.748918 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.749026 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.749940 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.752774 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.753017 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.753669 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.756615 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.757159 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.757529 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.760678 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.761247 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.761568 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.764821 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.765354 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.765671 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.768994 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.769863 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.770486 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.773104 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.773989 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.775879 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.777235 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.778129 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.781555 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.782404 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.783300 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.787589 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.787838 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.788694 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.793536 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.794390 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.795056 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.799597 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.800458 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.801147 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.807084 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.808010 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.813217 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.814158 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.818227 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.830428 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.831118 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.842416 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.848505 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.853203 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.854893 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.856176 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.857934 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.861041 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.862307 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.863307 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.865777 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.867043 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.868641 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.870552 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.871840 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.874922 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.875959 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.877284 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.881346 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.881644 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.882679 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.887468 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.887696 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.888983 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.893304 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.894422 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.895698 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.899285 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.900298 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.901596 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.905268 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.906174 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.907481 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.912206 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.912633 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.913533 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.918241 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.919588 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.920001 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.925658 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.927001 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.927688 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.933095 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.934430 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.935365 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.940785 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.941009 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.942157 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.946154 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.948799 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.949872 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.954225 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.954517 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.955341 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.959645 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.960075 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.960786 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.965623 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.968056 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.969189 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.973666 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.974801 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.976535 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.979262 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.980422 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.990257 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.991441 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.992316 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.006217 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.008080 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.010074 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.022197 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.026000 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.026538 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.040849 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.041904 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.052117 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.066693 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.067733 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.077721 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.092521 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.093521 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.103324 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.118384 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.119332 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.344635 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.350720 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.355555 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.360774 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.362214 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.365807 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.368528 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.368533 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.372022 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.372950 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.373452 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.376968 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.378485 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.378720 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.385165 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.385181 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.386418 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.390855 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.392887 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.394314 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.396427 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.397356 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.402721 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.402997 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.409217 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.409349 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.411935 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.418599 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.426927 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.428178 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.433751 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.442757 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.446119 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.453058 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.460860 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.461060 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.467824 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.479373 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.482660 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.486271 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.501216 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.508124 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.532256 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/16\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:34\u001b[0m 10s/step - loss: 2.2494" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731344675.551267 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.558180 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.626513 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.632559 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.634838 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.636536 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.641893 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.645258 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.646330 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.648353 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.650184 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.652424 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.653978 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.654034 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.654735 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.655884 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.656453 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.658924 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.660316 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.661882 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.662657 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.663580 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.664403 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.665305 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.667814 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.668438 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.669857 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.670158 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.673268 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.674055 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.675909 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.677115 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.679068 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.679117 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.682989 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.683823 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.684875 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.688185 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.688322 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.693038 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.697410 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 47ms/step - loss: 1.5546" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:36.377005: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-11 17:04:36.377079: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-11 17:04:36.377196: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731344676.922625 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.923061 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.924404 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.925094 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.926003 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.926970 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.929159 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.929176 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.929746 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.930805 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.931152 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.931601 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.932817 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.933188 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.933420 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.934503 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.934696 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.935238 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.935999 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.936247 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.937276 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.937577 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.937750 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.939008 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.939453 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.939573 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.940687 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.941197 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.941201 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.942749 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.942886 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.943188 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.944642 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.944645 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.944877 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.946379 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.947871 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.948369 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.948535 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.949964 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.950799 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.951078 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.951724 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.952761 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.953983 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.954753 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.955474 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.956676 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.957169 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.958569 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.959407 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.959818 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.961617 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.962184 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.962914 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.964320 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.964969 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.965353 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.966357 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.967712 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.968449 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.969078 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.970454 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.971185 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.973220 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.975955 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.977558 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.978386 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.978999 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.979594 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.979848 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.981061 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.984498 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.984813 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.985333 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.986264 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.986543 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.988239 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.989734 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.990681 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.991752 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.992426 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.994853 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.995214 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.996644 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.997752 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.000236 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.001968 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.002348 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.007479 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.012663 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.014869 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.020053 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.020224 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.022461 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.025440 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.027755 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.027770 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.033079 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.038843 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.040755 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.042239 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.044150 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.045474 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.045652 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.047561 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.048858 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.049890 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.051837 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.052268 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.053987 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.055956 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.056537 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.057395 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.059397 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.060651 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.061220 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.063239 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.064061 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.067890 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.074988 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.077156 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.081729 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.108531 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.111231 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.115569 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.141589 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.144549 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.148905 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.173301 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.176790 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.180963 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.204073 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.207902 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.212126 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.231311 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.235234 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.239358 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.286182 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.290779 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.294410 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.931128 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.934165 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.938730 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.939863 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.941833 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.942944 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.943325 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.944908 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.947551 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.948077 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.949516 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.951386 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.952170 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.954152 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.954863 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.956935 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.958918 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.960333 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.961130 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.962276 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.963841 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.965266 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.965770 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.969310 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.970145 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.972066 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.973471 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.974344 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.976217 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.978008 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.978530 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.980294 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.982895 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.983532 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.984505 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.987493 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.989112 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.989336 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.993053 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.994673 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.998992 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.000533 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.003255 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.009360 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.013121 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.014566 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.016069 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.019357 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.020682 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.023157 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.026127 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.027438 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.033283 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.034594 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.035905 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.041410 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.047413 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.054276 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.060660 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.063180 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.065695 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.068673 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.071638 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.072273 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.074117 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.074840 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.076533 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.077325 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.079021 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.079524 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.080316 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.081556 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.082434 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.083314 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.084070 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.085815 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.087116 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.087219 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.088271 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.090219 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.091098 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.091296 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.092671 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.094220 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.095182 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.095563 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.098209 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.098822 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.101133 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.102799 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.105730 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.107349 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.109821 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.112449 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.114571 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.124455 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.128657 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.132210 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.140775 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.149040 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.162447 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.174835 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.183636 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.195613 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.208347 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.216761 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.217188 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.229420 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.231278 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.238538 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.243474 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.252744 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.253810 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.264936 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.275397 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.901971 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.904711 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.907704 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.910645 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.913914 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.916512 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.917143 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.919269 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.920383 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.922270 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.924062 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.925249 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.928054 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.928665 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.928687 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.931461 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.931950 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.932305 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.934490 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.935206 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.936773 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.937626 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.938902 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.940935 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.941435 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.942852 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.944203 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.946536 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.947012 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.947523 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.951254 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.951423 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.952431 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.955248 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.956104 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.959070 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.959593 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.961238 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.964161 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.966339 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.967155 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.968935 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.973768 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.974143 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.980123 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.980469 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.981061 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.986825 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.986921 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.994489 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.994506 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.995332 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.001609 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.009055 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.009155 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.009259 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.015387 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.021328 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.022947 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.023635 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.035880 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.037447 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.046828 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.059847 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 230ms/step - loss: 1.5590 - val_loss: 2.3061\n", + "Epoch 2/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:39.127002: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m15/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m0s\u001b[0m 45ms/step - loss: 1.7682" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:40.061810: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 1.7967 - val_loss: 2.3604\n", + "Epoch 3/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.7963 - val_loss: 2.3494\n", + "Epoch 4/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:41.537500: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 102ms/step - loss: 1.7203 - val_loss: 2.3561\n", + "Epoch 5/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 61ms/step - loss: 1.7349 - val_loss: 2.4006\n", + "Epoch 6/100\n", + "\u001b[1m15/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m0s\u001b[0m 44ms/step - loss: 1.8499" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:45.361657: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.8798 - val_loss: 2.3912\n", + "Epoch 7/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 1.7793 - val_loss: 2.3783\n", + "Epoch 8/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 101ms/step - loss: 1.7978 - val_loss: 2.3552\n", + "Epoch 9/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 60ms/step - loss: 1.7480 - val_loss: 2.3508\n", + "Epoch 10/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.8378 - val_loss: 2.3515\n", + "Epoch 11/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.0080 - val_loss: 2.3325\n", + "Epoch 12/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:52.137767: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 103ms/step - loss: 2.0942 - val_loss: 2.3436\n", + "Epoch 13/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 60ms/step - loss: 2.0440 - val_loss: 2.3832\n", + "Epoch 14/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.0942 - val_loss: 2.3229\n", + "Epoch 15/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.0860 - val_loss: 2.3367\n", + "Epoch 16/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.0992 - val_loss: 2.3287\n", + "Epoch 17/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.0887 - val_loss: 2.3275\n", + "Epoch 18/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1043 - val_loss: 2.3126\n", + "Epoch 19/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.0803 - val_loss: 2.3147\n", + "Epoch 20/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 101ms/step - loss: 2.1872 - val_loss: 2.3127\n", + "Epoch 21/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.2357 - val_loss: 2.2820\n", + "Epoch 22/100\n", + "\u001b[1m15/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m0s\u001b[0m 45ms/step - loss: 2.2433" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:05:06.568759: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.2414 - val_loss: 2.2913\n", + "Epoch 23/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.0625 - val_loss: 2.2656\n", + "Epoch 24/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 98ms/step - loss: 2.2639 - val_loss: 2.2524\n", + "Epoch 25/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.2612 - val_loss: 2.2844\n", + "Epoch 26/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.2705 - val_loss: 2.2789\n", + "Epoch 27/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1526 - val_loss: 2.2727\n", + "Epoch 28/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 98ms/step - loss: 2.2515 - val_loss: 2.2493\n", + "Epoch 29/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 2.2440 - val_loss: 2.2570\n", + "Epoch 30/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.0894 - val_loss: 2.2228\n", + "Epoch 31/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.2351 - val_loss: 2.1996\n", + "Epoch 32/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.0900 - val_loss: 2.2334\n", + "Epoch 33/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.2224 - val_loss: 2.2086\n", + "Epoch 34/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1015 - val_loss: 2.2045\n", + "Epoch 35/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.2142 - val_loss: 2.2007\n", + "Epoch 36/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 97ms/step - loss: 2.0611 - val_loss: 2.1690\n", + "Epoch 37/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.2040 - val_loss: 2.1692\n", + "Epoch 38/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 2.1956 - val_loss: 2.1815\n", + "Epoch 39/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1908 - val_loss: 2.2030\n", + "Epoch 40/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 102ms/step - loss: 2.1984 - val_loss: 2.1693\n", + "Epoch 41/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1951 - val_loss: 2.1845\n", + "Epoch 42/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.9823 - val_loss: 2.1958\n", + "Epoch 43/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9765 - val_loss: 2.1814\n", + "Epoch 44/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:05:34.483472: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 97ms/step - loss: 2.1000 - val_loss: 2.1597\n", + "Epoch 45/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1804 - val_loss: 2.1576\n", + "Epoch 46/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1759 - val_loss: 2.1466\n", + "Epoch 47/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1689 - val_loss: 2.1498\n", + "Epoch 48/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 91ms/step - loss: 1.9566 - val_loss: 2.1511\n", + "Epoch 49/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9598 - val_loss: 2.1509\n", + "Epoch 50/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9598 - val_loss: 2.1570\n", + "Epoch 51/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 1.9635 - val_loss: 2.1548\n", + "Epoch 52/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 92ms/step - loss: 1.9644 - val_loss: 2.1494\n", + "Epoch 53/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 60ms/step - loss: 1.9602 - val_loss: 2.1599\n", + "Epoch 54/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9584 - val_loss: 2.1372\n", + "Epoch 55/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.0388 - val_loss: 2.1365\n", + "Epoch 56/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 82ms/step - loss: 2.1498 - val_loss: 2.1479\n", + "Epoch 57/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9569 - val_loss: 2.1332\n", + "Epoch 58/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1530 - val_loss: 2.1424\n", + "Epoch 59/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1529 - val_loss: 2.1472\n", + "Epoch 60/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 97ms/step - loss: 1.9496 - val_loss: 2.1263\n", + "Epoch 61/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.9690 - val_loss: 2.1322\n", + "Epoch 62/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1185 - val_loss: 2.1413\n", + "Epoch 63/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 1.9848 - val_loss: 2.1324\n", + "Epoch 64/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 91ms/step - loss: 1.9926 - val_loss: 2.1390\n", + "Epoch 65/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.9896 - val_loss: 2.1411\n", + "Epoch 66/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.9434 - val_loss: 2.1414\n", + "Epoch 67/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 1.9382 - val_loss: 2.1183\n", + "Epoch 68/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 102ms/step - loss: 1.9312 - val_loss: 2.1377\n", + "Epoch 69/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 1.9808 - val_loss: 2.1505\n", + "Epoch 70/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9460 - val_loss: 2.1340\n", + "Epoch 71/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1450 - val_loss: 2.1449\n", + "Epoch 72/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 1.9401 - val_loss: 2.1366\n", + "Epoch 73/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9378 - val_loss: 2.1495\n", + "Epoch 74/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9326 - val_loss: 2.1344\n", + "Epoch 75/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9310 - val_loss: 2.1381\n", + "Epoch 76/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 94ms/step - loss: 1.9268 - val_loss: 2.1261\n", + "Epoch 77/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9204 - val_loss: 2.1328\n", + "Epoch 78/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.0092 - val_loss: 2.1338\n", + "Epoch 79/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1239 - val_loss: 2.1350\n", + "Epoch 80/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 97ms/step - loss: 1.9275 - val_loss: 2.1374\n", + "Epoch 81/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 61ms/step - loss: 2.0664 - val_loss: 2.1221\n", + "Epoch 82/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1249 - val_loss: 2.1244\n", + "Epoch 83/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1204 - val_loss: 2.1372\n", + "Epoch 84/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.1233 - val_loss: 2.1534\n", + "Epoch 85/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 61ms/step - loss: 2.1277 - val_loss: 2.1218\n", + "Epoch 86/100\n", + "\u001b[1m15/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m0s\u001b[0m 45ms/step - loss: 2.1163" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:06:31.088524: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 2.1172 - val_loss: 2.1345\n", + "Epoch 87/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1168 - val_loss: 2.1383\n", + "Epoch 88/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 98ms/step - loss: 2.1165 - val_loss: 2.1303\n", + "Epoch 89/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1197 - val_loss: 2.1393\n", + "Epoch 90/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1235 - val_loss: 2.1378\n", + "Epoch 91/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1154 - val_loss: 2.1450\n", + "Epoch 92/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.1172 - val_loss: 2.1414\n", + "Epoch 93/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 60ms/step - loss: 2.1172 - val_loss: 2.1324\n", + "Epoch 94/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1195 - val_loss: 2.1508\n", + "Epoch 95/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1240 - val_loss: 2.1442\n", + "Epoch 96/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 98ms/step - loss: 2.1248 - val_loss: 2.1292\n", + "Epoch 97/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1182 - val_loss: 2.1416\n", + "Epoch 98/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 2.1198 - val_loss: 2.1398\n", + "Epoch 99/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1179 - val_loss: 2.1346\n", + "Epoch 100/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.1156 - val_loss: 2.1439\n" + ] + } + ], + "source": [ + "\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model_with_confidence= build_fixed_hits_model_with_confidence(input_shape=(tile_size, tile_size, 1), num_hits=max_hits_per_tile)\n", + " model_with_confidence.compile(optimizer='adam', loss=lambda y_true, y_pred: custom_loss_with_count_penalty(y_true, y_pred))\n", + "\n", + "\n", + " model_with_confidence.summary()\n", + "\n", + "# Train the model\n", + "history = model_with_confidence.fit(\n", + " train_dataset_prepared,\n", + " validation_data=val_dataset_prepared,\n", + " epochs=100, \n", + " verbose=1\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def aggregate_top_hits(tiles_predictions, num_hits=5, confidence_threshold=0.5):\n", + " # Combine predictions from all tiles in a single image\n", + " combined_predictions = np.concatenate(tiles_predictions, axis=0) # Shape: (num_tiles * num_hits, 3)\n", + " \n", + " # Filter predictions by confidence threshold\n", + " filtered_predictions = combined_predictions[combined_predictions[:, 2] >= confidence_threshold]\n", + " \n", + " # Sort filtered predictions by confidence score (3rd column)\n", + " sorted_predictions = filtered_predictions[filtered_predictions[:, 2].argsort()[::-1]] # Sort by confidence desc.\n", + " \n", + " # Select the top `num_hits` predictions based on confidence\n", + " top_hits = sorted_predictions[:num_hits, :2] # Keep only (x, y) coordinates of the top hits\n", + " \n", + " return top_hits\n", + "\n", + "\n", + "# Function to reconstruct the original image from tiles\n", + "def reconstruct_image(tiles, image_shape=(64, 64)):\n", + " tile_size = tiles.shape[1]\n", + " tiles_per_row = image_shape[1] // tile_size\n", + " tiles_per_col = image_shape[0] // tile_size\n", + " reconstructed = np.zeros(image_shape, dtype=tiles.dtype)\n", + " idx = 0\n", + " for i in range(tiles_per_col):\n", + " for j in range(tiles_per_row):\n", + " reconstructed[i*tile_size:(i+1)*tile_size, j*tile_size:(j+1)*tile_size] = tiles[idx]\n", + " idx += 1\n", + " return reconstructed\n", + "\n", + "def map_hits_to_image(image_idx, val_images, val_centroids, model, data_loader, num_tiles_per_side=4, confidence_threshold=0.5):\n", + " # Get the tiles and true centers for the specified image\n", + " tiles = val_images[image_idx] # Shape: (num_tiles, 16, 16)\n", + " true_centers = val_centroids[image_idx] # Shape: (num_tiles, 5, 2)\n", + "\n", + " num_tiles = tiles.shape[0]\n", + " tile_size = data_loader.tile_size\n", + "\n", + " # Collect predictions for each tile\n", + " tiles_predictions = []\n", + " for tile_idx, tile in enumerate(tiles):\n", + " tile_input = tile.reshape(1, tile_size, tile_size, 1).astype('float32')\n", + " tile_predictions = model.predict(tile_input)[0] # Shape: (num_hits, 3), with (x, y, confidence)\n", + " \n", + " # Apply confidence threshold to suppress low-confidence predictions\n", + " tile_predictions = tile_predictions[tile_predictions[:, 2] >= confidence_threshold]\n", + " \n", + " # Denormalize predictions within tile\n", + " tile_predictions[:, :2] *= tile_size\n", + " \n", + " # Adjust predictions to image-level coordinates\n", + " tile_row = tile_idx // num_tiles_per_side\n", + " tile_col = tile_idx % num_tiles_per_side\n", + " tile_predictions[:, 0] += tile_col * tile_size # x-coordinate\n", + " tile_predictions[:, 1] += tile_row * tile_size # y-coordinate\n", + " \n", + " tiles_predictions.append(tile_predictions)\n", + " \n", + " # Aggregate predictions across tiles to retain only the top 5 hits\n", + " top_5_hits = aggregate_top_hits(tiles_predictions, confidence_threshold=confidence_threshold)\n", + "\n", + " # Reconstruct the original image\n", + " reconstructed_image = reconstruct_image(tiles, image_shape=(tile_size*num_tiles_per_side, tile_size*num_tiles_per_side))\n", + "\n", + " # Initialize lists to hold image-level true and predicted hits\n", + " true_hits = []\n", + " for tile_idx in range(num_tiles):\n", + " tile_row = tile_idx // num_tiles_per_side\n", + " tile_col = tile_idx % num_tiles_per_side\n", + "\n", + " # True hits\n", + " for hit in true_centers[tile_idx]:\n", + " if not np.allclose(hit, [0.0, 0.0]):\n", + " img_x = tile_col * tile_size + hit[0] * tile_size\n", + " img_y = tile_row * tile_size + hit[1] * tile_size\n", + " true_hits.append((img_x, img_y))\n", + "\n", + " return reconstructed_image, true_hits, top_5_hits\n", + "\n", + "\n", + "# Visualization function to plot random images and their tiles with true and predicted hits\n", + "def visualize_random_predictions_with_tiles(val_images, val_centroids, model, data_loader, num_images_to_visualize=5, confidence_threshold=0.5):\n", + " num_tiles_per_side = data_loader.images.shape[1] // data_loader.tile_size # Assuming square images\n", + " total_images = len(val_images)\n", + " tile_size = data_loader.tile_size\n", + "\n", + " # Randomly select indices of images to visualize\n", + " random_indices = np.random.choice(total_images, num_images_to_visualize, replace=False)\n", + "\n", + " for img_idx in random_indices:\n", + " reconstructed_image, true_hits, pred_hits = map_hits_to_image(\n", + " img_idx, val_images, val_centroids, model, data_loader, num_tiles_per_side=num_tiles_per_side, confidence_threshold=confidence_threshold\n", + " )\n", + "\n", + " # Display the original image with predictions\n", + " plt.figure(figsize=(6, 6))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(f'Image {img_idx} with True and Predicted Hits')\n", + " \n", + " # Plot true hits\n", + " if true_hits:\n", + " true_x, true_y = zip(*true_hits)\n", + " plt.scatter(true_x, true_y, c='green', marker='o', label='True Hits', alpha=0.6, s=50)\n", + "\n", + " # Plot predicted hits\n", + " if pred_hits.size > 0:\n", + " pred_x, pred_y = zip(*pred_hits)\n", + " plt.scatter(pred_x, pred_y, c='red', marker='x', label='Predicted Hits', alpha=0.6, s=50)\n", + "\n", + " plt.legend()\n", + " plt.xlabel('X-coordinate')\n", + " plt.ylabel('Y-coordinate')\n", + " plt.show()\n", + "\n", + " # Display tiles with predictions\n", + " tiles = val_images[img_idx]\n", + " num_tiles = len(tiles)\n", + " \n", + " fig, axs = plt.subplots(num_tiles_per_side, num_tiles_per_side, figsize=(10, 10))\n", + " fig.suptitle(f'Tiles for Image {img_idx}')\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " tile = tiles[tile_idx]\n", + " tile_input = tile.reshape(1, tile_size, tile_size, 1).astype('float32')\n", + " tile_predictions = model.predict(tile_input)[0] # Shape: (num_hits, 3), with (x, y, confidence)\n", + " \n", + " # Apply confidence threshold to suppress low-confidence predictions\n", + " tile_predictions = tile_predictions[tile_predictions[:, 2] >= confidence_threshold]\n", + " \n", + " # Denormalize tile predictions to tile coordinates\n", + " tile_predictions[:, :2] *= tile_size\n", + " \n", + " ax.imshow(tile, cmap='gray')\n", + " ax.set_title(f'Tile {tile_idx}')\n", + " ax.axis('off')\n", + " \n", + " # Plot true hits for this tile\n", + " true_tile_hits = val_centroids[img_idx][tile_idx]\n", + " for hit in true_tile_hits:\n", + " if not np.allclose(hit, [0.0, 0.0]):\n", + " ax.plot(hit[0] * tile_size, hit[1] * tile_size, 'go', markersize=5, label='True Hits')\n", + "\n", + " # Plot predicted hits for this tile\n", + " for pred in tile_predictions:\n", + " ax.plot(pred[0], pred[1], 'rx', markersize=5, label='Predicted Hits')\n", + " \n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.9)\n", + " plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 805ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:08:12.633152: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 134ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 142ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 134ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 148ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 142ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 823ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 152ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 141ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 825ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 134ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 145ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 143ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# Adjust the confidence threshold as desired, e.g., 0.5 or higher to suppress low-confidence predictions\n", + "visualize_random_predictions_with_tiles(val_images, val_midpoints, model_with_confidence, data_loader, num_images_to_visualize=2, confidence_threshold=0.55)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=16, max_hits_per_tile=5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3752483/1796227132.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "\n", + "\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "# Create TensorFlow datasets for training and validation\n", + "batch_size = 1000\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", + "\n", + "train_dataset = train_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=True).batch(batch_size)\n", + "val_dataset = val_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=False).batch(batch_size)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0, 1.0, 0.9375, 0.9375)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(train_images), np.max(val_images), np.max(train_midpoints), np.max(val_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 0.0, 0.0, 0.0)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(train_images), np.min(val_images), np.min(train_midpoints), np.min(val_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + " \n", + "# Function to visualize the tiles and hits, excluding (0, 0) padding values\n", + "def visualize_tiles(dataset, tile_size=16, image_count=1):\n", + " \"\"\"\n", + " Visualizes a specified number of tiled images from the TensorFlow dataset with hit locations.\n", + "\n", + " Parameters:\n", + " - dataset: tf.data.Dataset, the dataset to visualize (train or val)\n", + " - tile_size: int, the size of each tile\n", + " - image_count: int, the number of images to visualize from the dataset\n", + " \"\"\"\n", + " # Take one batch from the dataset\n", + " for images, centers in dataset.take(1):\n", + " images_np = images.numpy()\n", + " centers_np = centers.numpy()\n", + "\n", + " # Visualize up to `image_count` images\n", + " for img_idx in range(min(image_count, images_np.shape[0])):\n", + " num_tiles = images_np.shape[1]\n", + " grid_size = int(np.ceil(np.sqrt(num_tiles))) # Determine grid size dynamically\n", + " fig, axs = plt.subplots(grid_size, grid_size, figsize=(8, 8))\n", + " fig.suptitle(f\"Tiled Image with Electron Hits (Image {img_idx})\")\n", + "\n", + " for idx, ax in enumerate(axs.flat):\n", + " if idx < num_tiles:\n", + " ax.imshow(images_np[img_idx, idx], cmap='gray')\n", + " # Filter out (0, 0) padding values before plotting\n", + " for (x, y) in centers_np[img_idx, idx]:\n", + " if (x, y) != (0, 0): # Only plot valid hits\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='x', s=30)\n", + " ax.axis('off')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage:\n", + "# Visualize only 1 or 2 images from the training dataset, excluding (0, 0) padding\n", + "visualize_tiles(train_dataset, tile_size=16, image_count=2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from tensorflow.keras import layers, Model\n", + "\n", + "def build_fixed_hits_model(input_shape=(16, 16, 1), num_hits=5):\n", + " output_units = num_hits * 2 # 2 coordinates (x, y) for each hit\n", + "\n", + " inputs = layers.Input(shape=input_shape)\n", + " \n", + " # Convolutional layers\n", + " x = layers.Conv2D(128, (5, 5), activation='relu', padding='same')(inputs)\n", + " x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)\n", + " x = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(x)\n", + " \n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + "\n", + " # Fully connected layers\n", + " x = layers.Flatten()(x)\n", + " x = layers.Dense(64, activation='relu')(x)\n", + "\n", + " # Output layer with exactly 5 (x, y) pairs\n", + " coordinates_output = layers.Dense(output_units, activation='sigmoid', name='coordinates_output')(x)\n", + " coordinates_output_reshaped = layers.Reshape((num_hits, 2), name='coordinates_output_reshaped')(coordinates_output)\n", + "\n", + " model = Model(inputs, coordinates_output_reshaped)\n", + " return model\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot sample tiles and hit locations\n", + "v = np.random.randint(0, len(data_loader.images))\n", + "tiles, hits_per_tile = data_loader.map_hits_to_tiles(data_loader.images[v], data_loader.centers[v])\n", + "\n", + "fig, axs = plt.subplots(4, 4, figsize=(12, 12))\n", + "for i, ax in enumerate(axs.flat):\n", + " tile = tiles[i]\n", + " hits = hits_per_tile[i]\n", + " \n", + " ax.imshow(tile, cmap='gray')\n", + " for (x, y) in hits:\n", + " ax.scatter(x, y, c='red', marker='x')\n", + " ax.axis('on')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + "# # Reshape reference_point to match the shape of midpoints for broadcasting\n", + "# reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + "# reference_point = tf.reshape(reference_point, (1, 1, 2)) # Shape (1, 1, 2)\n", + " \n", + "# # Reshape midpoints to (batch_size, num_hits, 2) for sorting\n", + "# midpoints = tf.reshape(midpoints, (-1, 5, 2)) # Assuming 5 hits per image\n", + " \n", + "# # Calculate Euclidean distances from the reference point\n", + "# distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_hits)\n", + " \n", + "# # Get sorted indices based on distances\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + "# # Gather sorted midpoints\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# # Define the reference point\n", + "# reference_point = (0.0, 0.0)\n", + " \n", + "# # Sort both y_true and y_pred based on distances from the reference point\n", + "# y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + "# y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + "# # Calculate Euclidean distance between sorted true and predicted midpoints\n", + "# diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss across all coordinates\n", + "# return tf.reduce_mean(powered_diff)\n", + " \n", + "# return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 16, 16, 1)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 16, 16, 128)    │         3,328 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 16, 16, 64)     │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 16, 16, 128)    │        73,856 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 8, 8, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 8192)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 64)             │       524,352 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ coordinates_output (Dense)      │ (None, 10)             │           650 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ coordinates_output_reshaped     │ (None, 5, 2)           │             0 │\n",
+       "│ (Reshape)                       │                        │               │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m3,328\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8192\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m524,352\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ coordinates_output (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m650\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ coordinates_output_reshaped │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 675,978 (2.58 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m675,978\u001b[0m (2.58 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 675,978 (2.58 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m675,978\u001b[0m (2.58 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with strategy.scope():\n", + " # Rebuild the model with the corrected input shape\n", + " model = build_fixed_hits_model(input_shape=(16, 16, 1), num_hits=5)\n", + "\n", + " # Compile the model\n", + " model.compile(optimizer='adam', loss='mse')\n", + "\n", + " # Display the model summary\n", + " model.summary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<_BatchDataset element_spec=(TensorSpec(shape=(None, 16, 16, 16), dtype=tf.float64, name=None), TensorSpec(shape=(None, 16, 5, 2), dtype=tf.float64, name=None))>" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "INFO:tensorflow:Error reported to Coordinator: Exception encountered when calling Functional.call().\n", + "\n", + "\u001b[1mInput 0 of layer \"conv2d\" is incompatible with the layer: expected axis -1 of input shape to have value 1, but received input with shape (None, 16, 16, 16)\u001b[0m\n", + "\n", + "Arguments received by Functional.call():\n", + " • inputs=tf.Tensor(shape=(None, 16, 16, 16), dtype=float64)\n", + " • training=True\n", + " • mask=None\n", + "Traceback (most recent call last):\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/training/coordinator.py\", line 293, in stop_on_exception\n", + " yield\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/mirrored_run.py\", line 387, in run\n", + " self.main_result = self.main_fn(*self.main_args, **self.main_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/autograph/impl/api.py\", line 643, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data\n", + " return self.train_step(data)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 51, in train_step\n", + " y_pred = self(x, training=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py\", line 122, in error_handler\n", + " raise e.with_traceback(filtered_tb) from None\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/input_spec.py\", line 227, in assert_input_compatibility\n", + " raise ValueError(\n", + "ValueError: Exception encountered when calling Functional.call().\n", + "\n", + "\u001b[1mInput 0 of layer \"conv2d\" is incompatible with the layer: expected axis -1 of input shape to have value 1, but received input with shape (None, 16, 16, 16)\u001b[0m\n", + "\n", + "Arguments received by Functional.call():\n", + " • inputs=tf.Tensor(shape=(None, 16, 16, 16), dtype=float64)\n", + " • training=True\n", + " • mask=None\n" + ] + }, + { + "ename": "ValueError", + "evalue": "in user code:\n\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data **\n return self.train_step(data)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 51, in train_step\n y_pred = self(x, training=True)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py\", line 122, in error_handler\n raise e.with_traceback(filtered_tb) from None\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/input_spec.py\", line 227, in assert_input_compatibility\n raise ValueError(\n\n ValueError: Exception encountered when calling Functional.call().\n \n \u001b[1mInput 0 of layer \"conv2d\" is incompatible with the layer: expected axis -1 of input shape to have value 1, but received input with shape (None, 16, 16, 16)\u001b[0m\n \n Arguments received by Functional.call():\n • inputs=tf.Tensor(shape=(None, 16, 16, 16), dtype=float64)\n • training=True\n • mask=None\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[9], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Train the model with the flattened dataset\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\n\u001b[1;32m 7\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py:122\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 119\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m 120\u001b[0m \u001b[38;5;66;03m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m 121\u001b[0m \u001b[38;5;66;03m# `keras.config.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m--> 122\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 123\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m/tmp/__autograph_generated_file7tzs3j2_.py:14\u001b[0m, in \u001b[0;36mouter_factory..inner_factory..tf__wrapped_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 13\u001b[0m do_return \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m retval_ \u001b[38;5;241m=\u001b[39m ag__\u001b[38;5;241m.\u001b[39mconverted_call(ag__\u001b[38;5;241m.\u001b[39mld(call_for_each_replica), (ag__\u001b[38;5;241m.\u001b[39mld(strategy), ag__\u001b[38;5;241m.\u001b[39mld(fn)\u001b[38;5;241m.\u001b[39mpython_function, ag__\u001b[38;5;241m.\u001b[39mld(args), ag__\u001b[38;5;241m.\u001b[39mld(kwargs)), \u001b[38;5;28;01mNone\u001b[39;00m, fscope)\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m:\n\u001b[1;32m 16\u001b[0m do_return \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "\u001b[0;31mValueError\u001b[0m: in user code:\n\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data **\n return self.train_step(data)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 51, in train_step\n y_pred = self(x, training=True)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py\", line 122, in error_handler\n raise e.with_traceback(filtered_tb) from None\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/input_spec.py\", line 227, in assert_input_compatibility\n raise ValueError(\n\n ValueError: Exception encountered when calling Functional.call().\n \n \u001b[1mInput 0 of layer \"conv2d\" is incompatible with the layer: expected axis -1 of input shape to have value 1, but received input with shape (None, 16, 16, 16)\u001b[0m\n \n Arguments received by Functional.call():\n • inputs=tf.Tensor(shape=(None, 16, 16, 16), dtype=float64)\n • training=True\n • mask=None\n" + ] + } + ], + "source": [ + "# Train the model with the flattened dataset\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=10, \n", + " verbose=1\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/10\u001b[0m \u001b[32m━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 466ms/step" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731270681.864030 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.864879 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.865243 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.865628 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.866005 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.866358 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.866752 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.867180 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.867587 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.868007 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.868523 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.869511 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.869509 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870075 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870153 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870477 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870840 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870967 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.871524 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.871767 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.871845 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.872080 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.872285 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.872690 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873004 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873070 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873276 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873529 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873818 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.874201 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.874428 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.874599 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.874782 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.875140 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.875579 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.875640 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.875913 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.876087 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.876928 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.876937 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.877096 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.877840 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.878114 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.878253 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.878699 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.879116 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.879671 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.879950 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.880484 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.881018 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.881550 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.881973 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.882506 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.882959 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.883480 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.884155 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.884664 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.889943 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.890426 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.890898 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.891332 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.891810 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.892300 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.892714 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.893188 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.893749 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.894433 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.895170 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.895844 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.895974 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.896515 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.896609 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.897090 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.897239 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.897319 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.897864 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.898050 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.898221 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.898517 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.898633 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.899288 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.899302 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.899885 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.899963 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.900522 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.900593 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.901066 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.901254 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.901640 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.901944 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.902339 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.902684 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.903073 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.903401 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.903779 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.904307 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.904683 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.905241 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.905620 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.911763 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.912303 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.912773 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.913246 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.913712 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.914134 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.914621 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.915012 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.915424 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.916018 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.916555 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.917618 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.918684 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.918900 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.919372 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.919448 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.919883 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.920115 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.920341 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.920738 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.920972 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.921069 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.921234 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.921489 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.921674 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922001 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922163 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922406 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922649 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922834 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.923246 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.923400 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.923526 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.923695 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.924088 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.924404 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.924502 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.924974 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.925179 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.926067 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.926321 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.926431 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.927139 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.928289 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.928463 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.929211 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.930657 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.931404 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.931728 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.932473 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.933609 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.934349 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.935444 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.936184 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.961099 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.961511 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.961981 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.962438 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.962895 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.963295 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.963842 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.964300 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.964741 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.965192 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.965657 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.966190 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.966716 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.967279 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.967854 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.968587 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.968869 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.969053 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.969361 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.969539 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.969791 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.970161 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.970365 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.970437 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.970965 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.971043 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.971648 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.971716 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.972188 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.972291 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.972873 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.972942 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.973462 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.973531 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.974047 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.974135 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.974562 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.974668 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.975077 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.975247 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.975647 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.975811 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.976197 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.976396 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.976761 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.976994 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.977352 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.977605 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.978215 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.978338 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.978434 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.978725 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.979127 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.979487 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.979736 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.979815 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.980200 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.980632 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.981128 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.981483 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.981932 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.982346 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.982796 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.983871 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.984911 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.986835 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.986993 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.987324 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.987421 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.987853 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.987927 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.988254 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.988423 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.988797 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989137 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989153 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989269 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989581 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989762 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990001 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990172 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990791 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990858 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990868 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.991293 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.991371 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.991892 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.991962 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.992340 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.992508 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.992525 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.993091 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.993161 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.993964 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.994316 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.994393 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.995510 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.995580 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.997580 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.997656 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.999702 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.999770 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.001175 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.001246 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.002658 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.002727 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.004411 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.004487 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.026895 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.027285 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.027674 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.028063 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.028466 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.028852 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.029248 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.029663 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.030079 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.030524 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.030978 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.031445 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.031924 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.032458 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.033017 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.033615 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.034690 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.035225 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.036295 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.036894 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.037358 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.037552 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038152 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038225 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038240 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038688 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038764 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039365 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039380 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039398 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039918 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039995 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.040477 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.040694 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.040718 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.040919 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.041113 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.041395 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.041560 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.042235 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.042367 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.042739 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.042906 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.043247 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.043418 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.043769 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.043936 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.044302 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.044466 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.044874 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.045041 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.045476 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.045642 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.046127 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.046290 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.047254 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.047421 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.047846 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.048007 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.048950 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.049126 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.049608 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.049775 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.050605 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.050776 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.051489 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.051655 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.052662 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.052831 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m10/10\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 20:31:22.132061: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + } + ], + "source": [ + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "train_dataset = train_dataset.batch(800)\n", + "output = model.predict(train_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def visualize_predictions(model, dataset, tile_size=16, max_hits_per_tile=5, images_to_visualize=3):\n", + " \"\"\"\n", + " Visualizes model predictions alongside ground truth hits for a specified number of images from the dataset.\n", + "\n", + " Parameters:\n", + " - model: Trained TensorFlow model.\n", + " - dataset: tf.data.Dataset, the dataset to visualize (e.g., val_dataset).\n", + " - tile_size: int, the size of each tile (default is 16).\n", + " - max_hits_per_tile: int, maximum number of hits per tile (default is 5).\n", + " - images_to_visualize: int, number of images to visualize from the dataset (default is 3).\n", + " \"\"\"\n", + " # Fetch a single batch from the dataset\n", + " for batch_images, batch_true_centers in dataset.take(1):\n", + " # Convert images and labels to NumPy arrays\n", + " images_np = batch_images.numpy()\n", + " true_centers_np = batch_true_centers.numpy()\n", + " \n", + " # Run the model to get predictions\n", + " predictions_np = model.predict(images_np)\n", + " \n", + " # Loop through the specified number of images\n", + " for img_idx in range(min(images_to_visualize, images_np.shape[0])):\n", + " num_tiles = images_np.shape[1]\n", + " grid_size = int(np.ceil(np.sqrt(num_tiles))) # Dynamically determine grid size\n", + " \n", + " fig, axs = plt.subplots(grid_size, grid_size, figsize=(15, 15))\n", + " fig.suptitle(f\"Image {img_idx + 1}: Ground Truth vs Predictions\", fontsize=16)\n", + " \n", + " for tile_idx in range(num_tiles):\n", + " row = tile_idx // grid_size\n", + " col = tile_idx % grid_size\n", + " ax = axs[row, col]\n", + " \n", + " # Display the tile image\n", + " tile_image = images_np[img_idx, tile_idx]\n", + " if tile_image.ndim == 2:\n", + " ax.imshow(tile_image, cmap='gray')\n", + " else:\n", + " ax.imshow(tile_image.squeeze(), cmap='gray') # Handle channels if present\n", + " \n", + " # Plot ground truth hits\n", + " for hit in true_centers_np[img_idx, tile_idx]:\n", + " x_gt, y_gt = hit\n", + " if not (x_gt == 0 and y_gt == 0): # Exclude padding\n", + " ax.scatter(x_gt * tile_size, y_gt * tile_size, \n", + " c='green', marker='o', label='Ground Truth')\n", + " \n", + " # Plot predicted hits\n", + " predicted_hits = predictions_np[img_idx, tile_idx]\n", + " for hit in predicted_hits:\n", + " x_pred, y_pred = hit\n", + " ax.scatter(x_pred * tile_size, y_pred * tile_size, \n", + " c='red', marker='x', label='Prediction')\n", + " \n", + " ax.axis('off') # Hide axis ticks\n", + " \n", + " # Create a single legend for the entire figure\n", + " handles, labels = axs[0,0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout(rect=[0, 0, 1, 0.96]) # Adjust layout to make space for the title and legend\n", + " plt.show()\n", + " \n", + " break # Only process the first batch\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index 1 is out of bounds for axis 1 with size 1", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[44], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Usage Example\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# Ensure that the model and val_dataset are already defined as per your workflow\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m \u001b[43mvisualize_predictions\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mdataset\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mtile_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m16\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_hits_per_tile\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[43mimages_to_visualize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Change this to visualize more or fewer images\u001b[39;49;00m\n\u001b[1;32m 10\u001b[0m \u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[42], line 53\u001b[0m, in \u001b[0;36mvisualize_predictions\u001b[0;34m(model, dataset, tile_size, max_hits_per_tile, images_to_visualize)\u001b[0m\n\u001b[1;32m 49\u001b[0m ax\u001b[38;5;241m.\u001b[39mscatter(x_gt \u001b[38;5;241m*\u001b[39m tile_size, y_gt \u001b[38;5;241m*\u001b[39m tile_size, \n\u001b[1;32m 50\u001b[0m c\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgreen\u001b[39m\u001b[38;5;124m'\u001b[39m, marker\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mo\u001b[39m\u001b[38;5;124m'\u001b[39m, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mGround Truth\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 52\u001b[0m \u001b[38;5;66;03m# Plot predicted hits\u001b[39;00m\n\u001b[0;32m---> 53\u001b[0m predicted_hits \u001b[38;5;241m=\u001b[39m \u001b[43mpredictions_np\u001b[49m\u001b[43m[\u001b[49m\u001b[43mimg_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtile_idx\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m hit \u001b[38;5;129;01min\u001b[39;00m predicted_hits:\n\u001b[1;32m 55\u001b[0m x_pred, y_pred \u001b[38;5;241m=\u001b[39m hit\n", + "\u001b[0;31mIndexError\u001b[0m: index 1 is out of bounds for axis 1 with size 1" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Usage Example\n", + "# Ensure that the model and val_dataset are already defined as per your workflow\n", + "\n", + "visualize_predictions(\n", + " model=model,\n", + " dataset=val_dataset,\n", + " tile_size=16,\n", + " max_hits_per_tile=5,\n", + " images_to_visualize=3 # Change this to visualize more or fewer images\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "# Define the function for visualizing midpoints\n", + "def visualize_midpoints(image, midpoints, title=\"Predicted Midpoint Visualization\"):\n", + " \"\"\"\n", + " Visualizes midpoints on an image without using a probability vector.\n", + "\n", + " Parameters:\n", + " - image: A 3D tensor representing the image.\n", + " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + " - title: The title of the plot.\n", + "\n", + " Returns:\n", + " None (displays the image with midpoints).\n", + " \"\"\"\n", + " # Convert to NumPy arrays for easier handling\n", + " image_np = image\n", + " midpoints_np = midpoints\n", + "\n", + " # Denormalize image if necessary (adjust based on your normalization method)\n", + " denormalized_image = image_np # Modify if normalization was applied during training\n", + "\n", + " # Visualize the image\n", + " plt.figure(figsize=(4, 4))\n", + " plt.imshow(denormalized_image, cmap='gray')\n", + " plt.title(title)\n", + "\n", + " # Plot midpoints directly, only if they are not (0, 0)\n", + " for i, (x, y) in enumerate(midpoints_np):\n", + " if x >= 0 and y >= 0: # Only plot if the point is not (0, 0)\n", + " plt.scatter(x, y, color='red', s=5)\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "Invalid shape (16, 16, 16) for image data", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[41], line 6\u001b[0m\n\u001b[1;32m 2\u001b[0m index_to_visualize \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;28mlen\u001b[39m(all_images))\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# index_to_visualize = 11548\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# Visualize the selected image with predicted and true midpoints\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m \u001b[43mvisualize_midpoints\u001b[49m\u001b[43m(\u001b[49m\u001b[43mall_images\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindex_to_visualize\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mall_pred_midpoints\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindex_to_visualize\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtitle\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mPredicted Midpoints\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m visualize_midpoints(all_images[index_to_visualize], all_true_midpoints[index_to_visualize, \u001b[38;5;241m0\u001b[39m, :, :] , title\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mGround Truth Midpoints\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "Cell \u001b[0;32mIn[35], line 27\u001b[0m, in \u001b[0;36mvisualize_midpoints\u001b[0;34m(image, midpoints, title)\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# Visualize the image\u001b[39;00m\n\u001b[1;32m 26\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m4\u001b[39m))\n\u001b[0;32m---> 27\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimshow\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdenormalized_image\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcmap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mgray\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 28\u001b[0m plt\u001b[38;5;241m.\u001b[39mtitle(title)\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m# Plot midpoints directly, only if they are not (0, 0)\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/pyplot.py:3562\u001b[0m, in \u001b[0;36mimshow\u001b[0;34m(X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, data, **kwargs)\u001b[0m\n\u001b[1;32m 3541\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mimshow)\n\u001b[1;32m 3542\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mimshow\u001b[39m(\n\u001b[1;32m 3543\u001b[0m X: ArrayLike \u001b[38;5;241m|\u001b[39m PIL\u001b[38;5;241m.\u001b[39mImage\u001b[38;5;241m.\u001b[39mImage,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 3560\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 3561\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m AxesImage:\n\u001b[0;32m-> 3562\u001b[0m __ret \u001b[38;5;241m=\u001b[39m \u001b[43mgca\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimshow\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 3563\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3564\u001b[0m \u001b[43m \u001b[49m\u001b[43mcmap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcmap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3565\u001b[0m \u001b[43m \u001b[49m\u001b[43mnorm\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnorm\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3566\u001b[0m \u001b[43m \u001b[49m\u001b[43maspect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maspect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3567\u001b[0m \u001b[43m \u001b[49m\u001b[43minterpolation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterpolation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3568\u001b[0m \u001b[43m \u001b[49m\u001b[43malpha\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43malpha\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3569\u001b[0m \u001b[43m \u001b[49m\u001b[43mvmin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvmin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3570\u001b[0m \u001b[43m \u001b[49m\u001b[43mvmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvmax\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3571\u001b[0m \u001b[43m \u001b[49m\u001b[43morigin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morigin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3572\u001b[0m \u001b[43m \u001b[49m\u001b[43mextent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextent\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3573\u001b[0m \u001b[43m \u001b[49m\u001b[43minterpolation_stage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterpolation_stage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3574\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilternorm\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilternorm\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3575\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilterrad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilterrad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3576\u001b[0m \u001b[43m \u001b[49m\u001b[43mresample\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresample\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3577\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3578\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdata\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m}\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m{\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3579\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3580\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3581\u001b[0m sci(__ret)\n\u001b[1;32m 3582\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m __ret\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/__init__.py:1473\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1470\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 1471\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner\u001b[39m(ax, \u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 1472\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1473\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1474\u001b[0m \u001b[43m \u001b[49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1475\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1476\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[43mk\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1478\u001b[0m bound \u001b[38;5;241m=\u001b[39m new_sig\u001b[38;5;241m.\u001b[39mbind(ax, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 1479\u001b[0m auto_label \u001b[38;5;241m=\u001b[39m (bound\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget(label_namer)\n\u001b[1;32m 1480\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m bound\u001b[38;5;241m.\u001b[39mkwargs\u001b[38;5;241m.\u001b[39mget(label_namer))\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/axes/_axes.py:5895\u001b[0m, in \u001b[0;36mAxes.imshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m 5892\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m aspect \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 5893\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mset_aspect(aspect)\n\u001b[0;32m-> 5895\u001b[0m \u001b[43mim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5896\u001b[0m im\u001b[38;5;241m.\u001b[39mset_alpha(alpha)\n\u001b[1;32m 5897\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m im\u001b[38;5;241m.\u001b[39mget_clip_path() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 5898\u001b[0m \u001b[38;5;66;03m# image does not already have clipping set, clip to Axes patch\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/image.py:729\u001b[0m, in \u001b[0;36m_ImageBase.set_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m 727\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(A, PIL\u001b[38;5;241m.\u001b[39mImage\u001b[38;5;241m.\u001b[39mImage):\n\u001b[1;32m 728\u001b[0m A \u001b[38;5;241m=\u001b[39m pil_to_array(A) \u001b[38;5;66;03m# Needed e.g. to apply png palette.\u001b[39;00m\n\u001b[0;32m--> 729\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_normalize_image_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43mA\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 730\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_imcache \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 731\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstale \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/image.py:697\u001b[0m, in \u001b[0;36m_ImageBase._normalize_image_array\u001b[0;34m(A)\u001b[0m\n\u001b[1;32m 695\u001b[0m A \u001b[38;5;241m=\u001b[39m A\u001b[38;5;241m.\u001b[39msqueeze(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m) \u001b[38;5;66;03m# If just (M, N, 1), assume scalar and apply colormap.\u001b[39;00m\n\u001b[1;32m 696\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m A\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m] \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m]):\n\u001b[0;32m--> 697\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid shape \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mA\u001b[38;5;241m.\u001b[39mshape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m for image data\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 698\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m:\n\u001b[1;32m 699\u001b[0m \u001b[38;5;66;03m# If the input data has values outside the valid range (after\u001b[39;00m\n\u001b[1;32m 700\u001b[0m \u001b[38;5;66;03m# normalisation), we issue a warning and then clip X to the bounds\u001b[39;00m\n\u001b[1;32m 701\u001b[0m \u001b[38;5;66;03m# - otherwise casting wraps extreme values, hiding outliers and\u001b[39;00m\n\u001b[1;32m 702\u001b[0m \u001b[38;5;66;03m# making reliable interpretation impossible.\u001b[39;00m\n\u001b[1;32m 703\u001b[0m high \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m255\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39missubdtype(A\u001b[38;5;241m.\u001b[39mdtype, np\u001b[38;5;241m.\u001b[39minteger) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m1\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: Invalid shape (16, 16, 16) for image data" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Select an index to visualize from the entire dataset\n", + "index_to_visualize = np.random.randint(0, len(all_images))\n", + "\n", + "# index_to_visualize = 11548\n", + "# Visualize the selected image with predicted and true midpoints\n", + "visualize_midpoints(all_images[index_to_visualize], all_pred_midpoints[index_to_visualize, 0, :, :] , title=\"Predicted Midpoints\")\n", + "visualize_midpoints(all_images[index_to_visualize], all_true_midpoints[index_to_visualize, 0, :, :] , title=\"Ground Truth Midpoints\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " return reconstructed_image\n", + "\n", + "def filter_predictions(predictions, threshold=0.5):\n", + " # Remove predictions close to (0,0) by applying a threshold\n", + " return [(x, y) for (x, y) in predictions if (x**2 + y**2) > threshold**2]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " # Initialize an empty array for the reconstructed image\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " \n", + " # Fill the reconstructed image with the tiles in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n", + "\n", + "def filter_predictions(predictions, threshold):\n", + " \"\"\"\n", + " Filters predictions by removing those close to (0, 0) using a threshold.\n", + " \n", + " Parameters:\n", + " - predictions: list of tuples representing predicted (x, y) coordinates.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \n", + " Returns:\n", + " - list of valid (x, y) predictions.\n", + " \"\"\"\n", + " return [(x, y) for (x, y) in predictions if (x**2 + y**2) > threshold**2]\n", + "\n", + "def visualize_predictions_without_confidence(model, dataset, tile_size=16, max_hits_per_tile=5, num_images=1, threshold = 0.6):\n", + " \"\"\"\n", + " Visualizes the model's predictions on a random sample of images from the dataset,\n", + " showing both the original image and tiled predictions without confidence filtering.\n", + "\n", + " Parameters:\n", + " - model: tf.keras.Model, the trained model to make predictions.\n", + " - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - num_images: int, number of random images to visualize.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \"\"\"\n", + " # Take one batch from the dataset for prediction\n", + " images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + " # Randomly select indices of images to visualize\n", + " num_tiles_per_image = 16 # 4x4 grid, 16 tiles per image\n", + " num_tiles_per_row = int(np.sqrt(num_tiles_per_image)) # Assuming a square grid\n", + " indices = random.sample(range(images.shape[0] // num_tiles_per_image), num_images) # Select random images\n", + "\n", + " # Make predictions on the entire batch\n", + " predictions = model.predict(images)\n", + "\n", + " # Visualize the selected images\n", + " for img_idx in indices:\n", + " # Select the tiles corresponding to the current image\n", + " image_tiles = images[img_idx * num_tiles_per_image : (img_idx + 1) * num_tiles_per_image]\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), \n", + " tile_size, \n", + " num_tiles_per_row\n", + " )\n", + "\n", + " # Plot the original image with overlayed predictions\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(6, 6))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + " # Overlay true and predicted centers on the original image\n", + " for tile_idx in range(num_tiles_per_image):\n", + " row_offset = (tile_idx // num_tiles_per_row) * tile_size\n", + " col_offset = (tile_idx % num_tiles_per_row) * tile_size\n", + "\n", + " # Get true and predicted centers for each tile\n", + " true_tile_centers = true_centers[img_idx * num_tiles_per_image + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * num_tiles_per_image + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Plot true hits in green\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted hits in red, with threshold filtering\n", + " for (x, y) in filter_predictions(predicted_tile_centers, threshold=threshold):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + " # Now plot the 4x4 tiled images with predictions and true hits\n", + " fig, axs = plt.subplots(num_tiles_per_row, num_tiles_per_row, figsize=(10, 10))\n", + " fig.suptitle(f\"Tiled Predictions and True Hits (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " true_tile_centers = true_centers[img_idx * num_tiles_per_image + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * num_tiles_per_image + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Display the tile\n", + " ax.imshow(images[img_idx * num_tiles_per_image + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + " # Plot true centers\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted centers with threshold filtering\n", + " for (x, y) in filter_predictions(predicted_tile_centers, threshold=threshold):\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " ax.axis('on')\n", + "\n", + " handles, labels = axs[0, 0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage with tile_size=16\n", + "visualize_predictions_without_confidence(model, val_dataset_flat, tile_size=16, max_hits_per_tile=5, num_images=2)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/All notebooks for Tiles/Tiling images Low Res.ipynb b/All notebooks for Tiles/Tiling images Low Res.ipynb new file mode 100644 index 0000000..104d466 --- /dev/null +++ b/All notebooks for Tiles/Tiling images Low Res.ipynb @@ -0,0 +1,1826 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:09:05.716250: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-10 18:09:05.729013: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-10 18:09:05.741784: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-10 18:09:05.745635: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-10 18:09:05.756730: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-10 18:09:06.383561: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:09:07.918048: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 77800 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-10 18:09:07.919485: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79070 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-10 18:09:07.920870: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import h5py\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " return images, centers\n", + "\n", + " def sort_centers(self, centers):\n", + " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [hits_per_tile[i] for i in range(len(tiles))]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " \"\"\"\n", + " Pads or truncates the hit coordinates for each tile to a fixed size (max_hits_per_tile).\n", + " \"\"\"\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + " return np.array(padded_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + "\n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_centers = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_centers, train_size=train_size, random_state=random_state)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/40KFixed_Mixed_5_16by16_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3516018/1698765166.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + "\n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images and centers\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile * 2) # Flatten hit locations\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "# Flatten the training and validation datasets\n", + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "val_images_flat, val_centers_flat = flatten_dataset(val_images, val_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Create TensorFlow datasets from the flattened data\n", + "batch_size = 1000\n", + "train_dataset_flat = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "val_dataset_flat = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "\n", + "def visualize_random_tiles(dataset, tile_size=8, max_hits_per_tile=5, image_count=1):\n", + " \"\"\"\n", + " Visualizes a specified number of random tiled images from the TensorFlow dataset with hit locations.\n", + "\n", + " Parameters:\n", + " - dataset: tf.data.Dataset, the dataset to visualize (train or val).\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_tile: int, the maximum number of hits per tile.\n", + " - image_count: int, the number of random images to visualize from the dataset.\n", + " \"\"\"\n", + " # Take one batch from the dataset\n", + " for images, centers in dataset.take(1):\n", + " images_np = images.numpy() # Shape: (num_tiles * num_images, tile_size, tile_size, 1)\n", + " centers_np = centers.numpy() # Shape: (num_tiles * num_images, max_hits_per_tile * 2)\n", + " \n", + " # Determine the number of images in the batch\n", + " num_images = images_np.shape[0] // 8 # Assuming 16 tiles per image for a 4x4 grid\n", + " \n", + " # Select random image indices\n", + " random_indices = random.sample(range(num_images), min(image_count, num_images))\n", + "\n", + " # Visualize the selected random images\n", + " for img_idx in random_indices:\n", + " fig, axs = plt.subplots(2, 2, figsize=(8, 8))\n", + " fig.suptitle(f\"Tiled Image with Electron Hits (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " tile_image = images_np[img_idx * 8 + tile_idx].reshape(tile_size, tile_size)\n", + " tile_centers = centers_np[img_idx * 8 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Plot the tile image\n", + " ax.imshow(tile_image, cmap='gray')\n", + "\n", + " # Plot valid hits\n", + " for (x, y) in tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='x', s=30)\n", + "\n", + " ax.axis('on')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:09:32.685682: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" + ] + } + ], + "source": [ + "visualize_random_tiles(val_dataset_flat, tile_size=8, max_hits_per_tile=5, image_count=2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "def build_model(tile_size=8, max_hits_per_tile=5):\n", + " \"\"\"\n", + " Builds a CNN model for predicting electron hit coordinates in each tile.\n", + "\n", + " Parameters:\n", + " - tile_size: int, the size of each tile (e.g., 8x8).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + "\n", + " Returns:\n", + " - model: tf.keras.Model, the compiled TensorFlow model.\n", + " \"\"\"\n", + " input_shape = (tile_size, tile_size, 1)\n", + " output_units = max_hits_per_tile * 2 # x, y coordinates for each hit\n", + "\n", + " model = tf.keras.Sequential([\n", + " # Convolutional layers to extract spatial features\n", + " tf.keras.layers.Conv2D(128, (3, 3), activation='relu', input_shape=input_shape),\n", + " # tf.keras.layers.MaxPooling2D((2, 2)),\n", + " tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " # tf.keras.layers.MaxPooling2D((2, 2)),\n", + " \n", + " # Flatten and fully connected layers for predicting coordinates\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(128, activation='relu'),\n", + " tf.keras.layers.Dense(64, activation='relu'),\n", + " tf.keras.layers.Dense(output_units, activation='sigmoid') # Sigmoid to keep values between 0 and 1\n", + " ])\n", + " \n", + " \n", + " return model\n", + "\n", + "# Define parameters\n", + "tile_size = 8\n", + "max_hits_per_tile = 5\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort both y_true and y_pred based on Euclidean distances\n", + " y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + " y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + " # Compute the difference\n", + " diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"sequential\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 4, 4, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 1024)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │       131,200 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 64)             │         8,256 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (Dense)                 │ (None, 10)             │           650 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1024\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m131,200\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m8,256\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m650\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 215,178 (840.54 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m215,178\u001b[0m (840.54 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 215,178 (840.54 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m215,178\u001b[0m (840.54 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with strategy.scope():\n", + " # Instantiate the model\n", + " model = build_model(tile_size=tile_size, max_hits_per_tile=max_hits_per_tile)\n", + " model.compile(optimizer='adam', loss=euclidean_sorted_custom_loss(exponent=2))\n", + " model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:00.150826: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-10 18:11:00.161427: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-10 18:11:00.168174: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731262260.247717 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.249720 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.250266 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.313081 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.313130 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.313192 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.313633 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.313805 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.313820 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.319142 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.319144 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.319166 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.336287 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.336451 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.336565 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.338654 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.338794 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.338967 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.339443 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.339455 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.339808 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.339928 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.340092 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.340305 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.342158 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.342189 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.342227 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.359797 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.359794 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.359934 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.360351 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.360396 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.360517 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.360891 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.360922 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.361142 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.361434 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.361464 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.361754 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.362015 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.362049 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.362359 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.362547 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.362576 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.362780 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.364807 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.364803 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.364937 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.367011 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.367052 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.367094 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.369147 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.369186 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.369227 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.371367 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.371487 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.371583 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.373488 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.373547 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.373584 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.376060 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.376072 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.376168 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.376508 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.377802 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.377935 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.377971 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.385691 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.385941 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.386059 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.387917 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.387938 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.388029 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.459512 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.459922 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.461215 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.461830 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.462151 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.462344 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.462811 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.462827 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.463250 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.463348 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.463786 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.463805 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.463962 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.464344 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.464354 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.464740 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.464968 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.464987 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.465231 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.465603 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.465655 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.465763 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.466052 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.466269 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.466283 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.466676 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.466776 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.466887 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.467193 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.467350 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.467484 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.467675 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.467919 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.468126 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.468258 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.468428 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.468657 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.468936 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.469084 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.469388 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.469649 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.469762 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.470167 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.470474 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.471079 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.471092 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.471238 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.471697 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.471707 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.472073 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.472288 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.472550 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.472820 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.472841 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.473083 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.473354 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.473374 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.473599 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.473860 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.473879 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.474122 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.474443 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.474546 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.474766 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.475006 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.475199 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.475276 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.475444 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.475827 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.475909 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.475918 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.476150 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.476374 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.476481 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.477075 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.477557 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.477591 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.477668 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.478142 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.478159 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.478188 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.478701 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.478731 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.478750 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.479064 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.480401 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.480476 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.480499 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.480986 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.481010 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.481144 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.481663 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.481741 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.481936 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.482432 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.482449 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.482467 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.483055 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.483071 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.483094 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.483366 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.483960 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.484537 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.484570 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.484639 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.485291 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.485320 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.485398 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.485715 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.491899 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.491987 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.492104 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.492466 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.492691 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.492736 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.492931 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.493321 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.493362 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.493541 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.494019 3516388 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.494031 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/32\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:45\u001b[0m 5s/step - loss: 0.2060" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731262260.675181 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.675225 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.677493 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.677515 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.679854 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.679873 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.682243 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.682260 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.685742 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.685760 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.686140 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.686157 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.686606 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.686624 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.687052 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.687070 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.687620 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.687637 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.688189 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.688209 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.688647 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.688664 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.689090 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.689107 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.689480 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.689582 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.689943 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.690472 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.690621 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.690728 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.691600 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.691779 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.691909 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.692770 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.692822 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.692951 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.693927 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.694070 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.694231 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.694484 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.694728 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.694850 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.695113 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.695287 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.695382 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.695856 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.695984 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.696070 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.696573 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.696665 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.696795 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.697001 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.697307 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.697602 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.697900 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.698235 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.699422 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.702423 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.703120 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.703136 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.703171 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.703775 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.703881 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.703994 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.704466 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.704967 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.705431 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.709046 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.709522 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.724259 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.724599 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.724894 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.725169 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.725558 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.725745 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.725863 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.726132 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.726332 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.726531 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.726929 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.727458 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.727470 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.727597 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.727794 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.728311 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.729769 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.730260 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.730372 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.730883 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.731012 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.731169 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.731288 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.731484 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.733671 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.733798 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.733817 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.735686 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.735706 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.735783 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.736330 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.736360 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.736492 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.737003 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.737036 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.737115 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.737620 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.737655 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.737727 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.739519 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.739529 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.739546 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.740312 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.740321 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.740338 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.740958 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.740975 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.740988 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.741666 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.741678 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.741694 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.742349 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.742372 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.742390 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.743471 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.743651 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.743670 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.744674 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.745048 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.745065 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.745734 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.746376 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.746393 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.759124 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.759127 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.759534 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.760125 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.760247 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.760265 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.760637 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.760764 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.760779 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.761498 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.761527 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.761612 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.762134 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.762170 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.762237 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.762770 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.762798 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.762884 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.763338 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.763374 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.763729 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.764026 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.764059 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.764293 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.764660 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.764698 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.764800 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.765581 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.765614 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.765701 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.766221 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.766258 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.766343 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.766860 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.766891 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.766978 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.767441 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.767475 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.767564 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.768082 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.768112 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.768204 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.768707 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.768741 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.768826 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.769336 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.769366 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.769458 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.769942 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.769959 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.769978 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.770533 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.770568 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.770645 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.771496 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.771511 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.771531 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.772117 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.772128 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.772157 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.772731 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.772744 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.772765 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.774144 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.774274 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.774293 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.774707 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.774899 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.774917 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.775144 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.775446 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.775600 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.775714 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.775933 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.776211 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.776237 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.776408 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.776804 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.776856 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.776962 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.777548 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.777625 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.777638 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.777967 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.780465 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.780477 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.780498 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.781471 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.781491 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.781570 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.782417 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.782414 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.782439 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.784535 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.784609 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.784622 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.785437 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.785643 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.785655 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.787580 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.787596 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.787616 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.788563 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.788588 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.788665 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.790821 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.790828 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.790845 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.792573 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.792658 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.792671 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.793535 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.793552 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.793572 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.794500 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.794520 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.794541 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.795185 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.795268 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.795278 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.797419 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.797577 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.797590 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.798072 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.798267 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.798285 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.798657 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.798871 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.798941 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.801451 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.801461 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.801482 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.814497 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.814756 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.814757 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.814825 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.815377 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.815414 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.815494 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.815913 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.815928 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.816870 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.816951 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.816966 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.817498 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.817569 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.817583 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.818128 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.818220 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.818245 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.818786 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.818866 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.818894 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.819443 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.819520 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.819533 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.820096 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.820176 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.820188 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.820757 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.820838 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.820852 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.821472 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.821552 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.821565 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.826725 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.826740 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.826757 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.827277 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.827297 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.827312 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.828082 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.828098 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.828115 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.828818 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.828838 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.828853 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.829508 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.829533 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.829546 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.830108 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.830128 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.830144 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.831209 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.831229 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.831245 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.832561 3516379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.832581 3516394 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262260.832596 3516397 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m31/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.1423" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:01.172791: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-10 18:11:01.172914: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - loss: 0.1390 - val_loss: 0.0407\n", + "Epoch 2/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731262261.635026 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.639101 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.639389 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.640721 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.640772 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.640828 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.641464 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.641471 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.641503 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.642128 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.642161 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.642186 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.642833 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.642859 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.642888 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.643459 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.643516 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.643589 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.644134 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.644168 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.644244 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.644778 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.644817 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.644879 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.645655 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.645690 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.645724 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.646347 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.646401 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.646454 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.647076 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.647113 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.647200 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.647722 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.647774 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.647883 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.648461 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.648519 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.648591 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.649230 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.649265 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.649344 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.649916 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.649953 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.650025 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.673766 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.674290 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.674659 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.674667 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.674902 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.675228 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.675543 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.675719 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.675897 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.677140 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.677218 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.677248 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.677933 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.678012 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.678038 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.678694 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.678708 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.678994 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.679306 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.679328 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.679629 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.680028 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.680049 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.680383 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.680927 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.681003 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.681245 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.681624 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.681777 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.681850 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.682299 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.682523 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.682553 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.682807 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.683152 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.683186 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.685906 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.685954 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.686075 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.686965 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.687002 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.687107 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.687860 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.687911 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.688060 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.688736 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.688771 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.688874 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.689815 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.689850 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.689924 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.692363 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.692401 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.692499 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.693071 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.693123 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.693212 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.693810 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.693874 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.693941 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.694523 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.694574 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.694662 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.695255 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.695310 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.695407 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.695947 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.696009 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.696088 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.696609 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.696661 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.696748 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.697340 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.697384 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.697467 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.698056 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.698120 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.698201 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.698718 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.698772 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.698856 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.699431 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.699485 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.699579 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.700171 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.700214 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.700292 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.700874 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.700925 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.701015 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.701603 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.701644 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.701715 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.702497 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.702538 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.702624 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.703214 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.703304 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.703359 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.703912 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.703972 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.704035 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.704804 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.704843 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.704929 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.705290 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.706182 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.706273 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.706708 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.706948 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.707012 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.707320 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.707757 3516396 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.707833 3516390 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731262261.707968 3516384 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "2024-11-10 18:11:01.731815: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0390" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:02.251904: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 40ms/step - loss: 0.0390 - val_loss: 0.0370\n", + "Epoch 3/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0365 - val_loss: 0.0358\n", + "Epoch 4/100\n", + "\u001b[1m 1/32\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 146ms/step - loss: 0.0350" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:03.784473: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0343 - val_loss: 0.0327\n", + "Epoch 5/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0286 - val_loss: 0.0243\n", + "Epoch 6/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0197 - val_loss: 0.0159\n", + "Epoch 7/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:05.303140: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0126 - val_loss: 0.0109\n", + "Epoch 8/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0092 - val_loss: 0.0084\n", + "Epoch 9/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0073 - val_loss: 0.0069\n", + "Epoch 10/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0060 - val_loss: 0.0058\n", + "Epoch 11/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0051 - val_loss: 0.0050\n", + "Epoch 12/100\n", + "\u001b[1m 1/32\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 133ms/step - loss: 0.0043" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:09.286371: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0045 - val_loss: 0.0046\n", + "Epoch 13/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0041 - val_loss: 0.0042\n", + "Epoch 14/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0037 - val_loss: 0.0039\n", + "Epoch 15/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0034 - val_loss: 0.0037\n", + "Epoch 16/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0032 - val_loss: 0.0036\n", + "Epoch 17/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 17ms/step - loss: 0.0031 - val_loss: 0.0033\n", + "Epoch 18/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0029 - val_loss: 0.0032\n", + "Epoch 19/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0028 - val_loss: 0.0030\n", + "Epoch 20/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0027 - val_loss: 0.0029\n", + "Epoch 21/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0026 - val_loss: 0.0027\n", + "Epoch 22/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0025 - val_loss: 0.0028\n", + "Epoch 23/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:15.713986: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0025 - val_loss: 0.0027\n", + "Epoch 24/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0024 - val_loss: 0.0025\n", + "Epoch 25/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0024 - val_loss: 0.0024\n", + "Epoch 26/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 26ms/step - loss: 0.0023 - val_loss: 0.0025\n", + "Epoch 27/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0023 - val_loss: 0.0024\n", + "Epoch 28/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0024\n", + "Epoch 29/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0024\n", + "Epoch 30/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0024\n", + "Epoch 31/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0021 - val_loss: 0.0023\n", + "Epoch 32/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0021 - val_loss: 0.0022\n", + "Epoch 33/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0021 - val_loss: 0.0022\n", + "Epoch 34/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 38ms/step - loss: 0.0020 - val_loss: 0.0022\n", + "Epoch 35/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0020 - val_loss: 0.0022\n", + "Epoch 36/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0023\n", + "Epoch 37/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0019 - val_loss: 0.0024\n", + "Epoch 38/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0019 - val_loss: 0.0024\n", + "Epoch 39/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0019 - val_loss: 0.0023\n", + "Epoch 40/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0019 - val_loss: 0.0023\n", + "Epoch 41/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0018 - val_loss: 0.0022\n", + "Epoch 42/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 30ms/step - loss: 0.0018 - val_loss: 0.0021\n", + "Epoch 43/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0017 - val_loss: 0.0020\n", + "Epoch 44/100\n", + "\u001b[1m 1/32\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 134ms/step - loss: 0.0017" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:29.725977: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0017 - val_loss: 0.0020\n", + "Epoch 45/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0017 - val_loss: 0.0020\n", + "Epoch 46/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0017 - val_loss: 0.0020\n", + "Epoch 47/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0018 - val_loss: 0.0021\n", + "Epoch 48/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0017 - val_loss: 0.0020\n", + "Epoch 49/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0017 - val_loss: 0.0018\n", + "Epoch 50/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.0016 - val_loss: 0.0018\n", + "Epoch 51/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0016 - val_loss: 0.0018\n", + "Epoch 52/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0016 - val_loss: 0.0019\n", + "Epoch 53/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0016 - val_loss: 0.0020\n", + "Epoch 54/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0016 - val_loss: 0.0018\n", + "Epoch 55/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0015 - val_loss: 0.0018\n", + "Epoch 56/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0016 - val_loss: 0.0018\n", + "Epoch 57/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0016 - val_loss: 0.0018\n", + "Epoch 58/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.0016 - val_loss: 0.0018\n", + "Epoch 59/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0015 - val_loss: 0.0018\n", + "Epoch 60/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0015 - val_loss: 0.0018\n", + "Epoch 61/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0015 - val_loss: 0.0018\n", + "Epoch 62/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0015 - val_loss: 0.0018\n", + "Epoch 63/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0015 - val_loss: 0.0018\n", + "Epoch 64/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0014 - val_loss: 0.0018\n", + "Epoch 65/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 66/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 37ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 67/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0014 - val_loss: 0.0018\n", + "Epoch 68/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0014 - val_loss: 0.0018\n", + "Epoch 69/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0014 - val_loss: 0.0018\n", + "Epoch 70/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0014 - val_loss: 0.0018\n", + "Epoch 71/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0015 - val_loss: 0.0017\n", + "Epoch 72/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0015 - val_loss: 0.0017\n", + "Epoch 73/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0015 - val_loss: 0.0018\n", + "Epoch 74/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 17ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 75/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 76/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0013 - val_loss: 0.0017\n", + "Epoch 77/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 78/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 79/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 80/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 81/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0013 - val_loss: 0.0017\n", + "Epoch 82/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0013 - val_loss: 0.0017\n", + "Epoch 83/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0014 - val_loss: 0.0018\n", + "Epoch 84/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0013 - val_loss: 0.0017\n", + "Epoch 85/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0013 - val_loss: 0.0018\n", + "Epoch 86/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0014 - val_loss: 0.0016\n", + "Epoch 87/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 18:11:56.901936: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0013 - val_loss: 0.0017\n", + "Epoch 88/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0013 - val_loss: 0.0018\n", + "Epoch 89/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.0013 - val_loss: 0.0019\n", + "Epoch 90/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 35ms/step - loss: 0.0013 - val_loss: 0.0019\n", + "Epoch 91/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0013 - val_loss: 0.0020\n", + "Epoch 92/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0014 - val_loss: 0.0019\n", + "Epoch 93/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0014 - val_loss: 0.0017\n", + "Epoch 94/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0013 - val_loss: 0.0018\n", + "Epoch 95/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0013 - val_loss: 0.0018\n", + "Epoch 96/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0014 - val_loss: 0.0020\n", + "Epoch 97/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0013 - val_loss: 0.0020\n", + "Epoch 98/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 36ms/step - loss: 0.0014 - val_loss: 0.0024\n", + "Epoch 99/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 15ms/step - loss: 0.0016 - val_loss: 0.0021\n", + "Epoch 100/100\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0017 - val_loss: 0.0019\n" + ] + } + ], + "source": [ + "# Train the model with the flattened dataset\n", + "history = model.fit(\n", + " train_dataset_flat,\n", + " validation_data=val_dataset_flat,\n", + " epochs=100, \n", + " verbose=1\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import random\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_predictions_with_original(model, dataset, tile_size=8, max_hits_per_tile=5, num_images=1, threshold=0.1):\n", + " \"\"\"\n", + " Visualizes the model's predictions on a random sample of images from the dataset,\n", + " showing both the original image and tiled predictions.\n", + "\n", + " Parameters:\n", + " - model: tf.keras.Model, the trained model to make predictions.\n", + " - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - num_images: int, number of random images to visualize.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \"\"\"\n", + " # Take one batch from the dataset for prediction\n", + " images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + " # Randomly select indices of images to visualize\n", + " indices = random.sample(range(images.shape[0] // 4), num_images)\n", + "\n", + " # Make predictions on the batch\n", + " predictions = model.predict(images)\n", + "\n", + " # Visualize the selected images\n", + " for img_idx in indices:\n", + " # Reconstruct the original image from tiles\n", + " tiles = images[img_idx * 4 : (img_idx + 1) * 4]\n", + " reconstructed_image = reconstruct_image_from_tiles(tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 2) # Assuming 2x2 tiles for 4 tiles per image\n", + "\n", + " # Plot the original image with overlayed predictions\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + " # Overlay true and predicted centers on the original image\n", + " for tile_idx in range(4): # Assuming 2x2 tiles\n", + " row_offset = (tile_idx // 2) * tile_size\n", + " col_offset = (tile_idx % 2) * tile_size\n", + "\n", + " # Get true and predicted centers for each tile\n", + " true_tile_centers = true_centers[img_idx * 4 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 4 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Plot true hits in green\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted hits in red, with threshold check\n", + " for (x, y) in predicted_tile_centers:\n", + " # Ignore (0, 0) or predictions close to it\n", + " if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + " # Now plot the tiled images with predictions\n", + " fig, axs = plt.subplots(2, 2, figsize=(6, 6))\n", + " fig.suptitle(f\"Tiled Predictions (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " true_tile_centers = true_centers[img_idx * 4 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 4 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Display the tile\n", + " ax.imshow(images[img_idx * 4 + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + " # Plot true centers\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted centers with threshold check\n", + " for (x, y) in predicted_tile_centers:\n", + " # Ignore (0, 0) or predictions close to it\n", + " if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " ax.axis('off')\n", + "\n", + " handles, labels = axs[0, 0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example usage\n", + "visualize_predictions_with_original(model, val_dataset_flat, tile_size=8, max_hits_per_tile=5, num_images=2, threshold=0.1)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/All notebooks for Tiles/Tiling images.ipynb b/All notebooks for Tiles/Tiling images.ipynb new file mode 100644 index 0000000..cc3b45e --- /dev/null +++ b/All notebooks for Tiles/Tiling images.ipynb @@ -0,0 +1,2329 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:44:31.373813: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-09 22:44:31.386088: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-09 22:44:31.398695: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-09 22:44:31.402514: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-09 22:44:31.413310: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-09 22:44:32.031476: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:44:35.965461: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 78643 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-09 22:44:35.967062: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79068 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-09 22:44:35.968493: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79194 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import h5py\n", + "# import tensorflow as tf\n", + "# from sklearn.model_selection import train_test_split\n", + "# import matplotlib.pyplot as plt\n", + "\n", + "# class DataLoader:\n", + "# def __init__(self, h5_filename, tile_size=16, max_hits_per_tile=5):\n", + "# self.h5_filename = h5_filename\n", + "# self.tile_size = tile_size\n", + "# self.max_hits_per_tile = max_hits_per_tile\n", + "# self.images, self.centers = self.load_data()\n", + "\n", + "# def load_data(self):\n", + "# with h5py.File(self.h5_filename, 'r') as f:\n", + "# images = np.array(f['images'][:10000])\n", + "# centers = np.array(f['centers_training'][:10000])\n", + "# return images, centers\n", + "\n", + "# def sort_centers(self, centers):\n", + "# return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + "# def tile_image(self, image):\n", + "# tiles = []\n", + "# for i in range(0, image.shape[0], self.tile_size):\n", + "# for j in range(0, image.shape[1], self.tile_size):\n", + "# tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + "# tiles.append(tile)\n", + "# return np.array(tiles)\n", + "\n", + "# def map_hits_to_tiles(self, image, centers):\n", + "# tiles = self.tile_image(image)\n", + "# hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + "# for hit in centers:\n", + "# _, x, y = hit\n", + "# tile_row = int(y // self.tile_size)\n", + "# tile_col = int(x // self.tile_size)\n", + "# tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + "# local_x = x % self.tile_size\n", + "# local_y = y % self.tile_size\n", + "# hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + "# return tiles, hits_per_tile\n", + "\n", + "# def process_data(self):\n", + "# tiled_images = []\n", + "# tiled_centers = []\n", + "\n", + "# for img_idx in range(len(self.images)):\n", + "# image = self.images[img_idx]\n", + "# centers = self.centers[img_idx]\n", + "# tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + "# tiled_images.append(tiles)\n", + "\n", + "# tile_hits_list = [hits_per_tile[i] for i in range(len(tiles))]\n", + "# tiled_centers.append(tile_hits_list)\n", + "\n", + "# return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + "# def pad_hits(self, centers):\n", + "# \"\"\"\n", + "# Pads or truncates the hit coordinates for each tile to a fixed size (max_hits_per_tile).\n", + "# \"\"\"\n", + "# padded_centers = []\n", + "# for image_centers in centers:\n", + "# padded_image_centers = []\n", + "# for tile_centers in image_centers:\n", + "# # Pad or truncate to ensure exactly max_hits_per_tile hits per tile\n", + "# padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + "# padded_image_centers.append(padded_tile_centers)\n", + "# padded_centers.append(padded_image_centers)\n", + "# return np.array(padded_centers)\n", + "\n", + "# def normalize_data(self):\n", + "# tiled_images, tiled_centers = self.process_data()\n", + "# normalized_images = tiled_images / np.max(tiled_images)\n", + "\n", + "# # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + "# normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + "# for tile in image_centers] for image_centers in tiled_centers]\n", + "# padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + "# return normalized_images, np.array(padded_centers)\n", + "\n", + "# def split_data(self, train_size=0.8, random_state=42):\n", + "# normalized_images, normalized_centers = self.normalize_data()\n", + "# return train_test_split(normalized_images, normalized_centers, train_size=train_size, random_state=random_state)\n", + "\n", + "# # Instantiate DataLoader and process data\n", + "# file_path = '/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "# data_loader = DataLoader(file_path, tile_size=16)\n", + "# train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "# def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + "# \"\"\"\n", + "# Flattens the dataset to treat each tile as an independent example.\n", + "\n", + "# Parameters:\n", + "# - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + "# - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + "# - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + "# - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + "# Returns:\n", + "# - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + "# - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + "# \"\"\"\n", + "# # Reshape images and centers\n", + "# num_images, num_tiles, _, _ = images.shape\n", + "# flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "# flat_centers = centers.reshape(-1, max_hits_per_tile * 2) # Flatten hit locations\n", + "\n", + "# return flat_images, flat_centers\n", + "\n", + "# # Flatten the training and validation datasets\n", + "# train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=16, max_hits_per_tile=5)\n", + "# val_images_flat, val_centers_flat = flatten_dataset(val_images, val_midpoints, tile_size=16, max_hits_per_tile=5)\n", + "\n", + "# # Create TensorFlow datasets from the flattened data\n", + "# batch_size = 1000\n", + "# train_dataset_flat = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "# val_dataset_flat = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + "\n", + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "# import random\n", + "\n", + "# def visualize_random_tiles(dataset, tile_size=16, max_hits_per_tile=5, image_count=1):\n", + "# \"\"\"\n", + "# Visualizes a specified number of random tiled images from the TensorFlow dataset with hit locations.\n", + "\n", + "# Parameters:\n", + "# - dataset: tf.data.Dataset, the dataset to visualize (train or val).\n", + "# - tile_size: int, the size of each tile.\n", + "# - max_hits_per_tile: int, the maximum number of hits per tile.\n", + "# - image_count: int, the number of random images to visualize from the dataset.\n", + "# \"\"\"\n", + "# # Take one batch from the dataset\n", + "# for images, centers in dataset.take(1):\n", + "# images_np = images.numpy() # Shape: (num_tiles * num_images, tile_size, tile_size, 1)\n", + "# centers_np = centers.numpy() # Shape: (num_tiles * num_images, max_hits_per_tile * 2)\n", + " \n", + "# # Determine the number of images in the batch\n", + "# num_images = images_np.shape[0] // 16 # Assuming 16 tiles per image for a 4x4 grid\n", + " \n", + "# # Select random image indices\n", + "# random_indices = random.sample(range(num_images), min(image_count, num_images))\n", + "\n", + "# # Visualize the selected random images\n", + "# for img_idx in random_indices:\n", + "# fig, axs = plt.subplots(4, 4, figsize=(8, 8))\n", + "# fig.suptitle(f\"Tiled Image with Electron Hits (Image {img_idx})\")\n", + "\n", + "# for tile_idx, ax in enumerate(axs.flat):\n", + "# tile_image = images_np[img_idx * 16 + tile_idx].reshape(tile_size, tile_size)\n", + "# tile_centers = centers_np[img_idx * 16 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + "# # Plot the tile image\n", + "# ax.imshow(tile_image, cmap='gray')\n", + "\n", + "# # Plot valid hits\n", + "# for (x, y) in tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax.scatter(x * tile_size, y * tile_size, c='red', marker='x', s=30)\n", + "\n", + "# ax.axis('off')\n", + "\n", + "# plt.tight_layout()\n", + "# plt.show()\n", + "\n", + "# visualize_random_tiles(val_dataset_flat, tile_size=16, max_hits_per_tile=5, image_count=2)\n", + "\n", + "# import tensorflow as tf\n", + "# from tensorflow.keras import layers\n", + "# def build_model(tile_size=16, max_hits_per_tile=5):\n", + "# \"\"\"\n", + "# Builds a CNN model for predicting electron hit coordinates in each tile.\n", + "\n", + "# Parameters:\n", + "# - tile_size: int, the size of each tile (e.g., 8x8).\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "\n", + "# Returns:\n", + "# - model: tf.keras.Model, the compiled TensorFlow model.\n", + "# \"\"\"\n", + " \n", + "# output_units = max_hits_per_tile * 2 \n", + "\n", + " \n", + "# x_input = layers.Input(shape=(tile_size, tile_size, 1))\n", + "# x = layers.Conv2D(512, kernel_size=5, activation='relu')(x_input)\n", + "# x = layers.MaxPooling2D()(x)\n", + "# x = layers.Conv2D(256, kernel_size=3, activation='relu')(x)\n", + "# # x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " \n", + "# x = layers.Flatten()(x)\n", + "# x = layers.Dense(128, activation='relu')(x)\n", + "# x = layers.Dense(64, activation='relu')(x)\n", + "# x_midpoints = layers.Dense(output_units, activation='sigmoid',name='x_midpoints')(x)\n", + "# model = tf.keras.Model(x_input, x_midpoints)\n", + " \n", + " \n", + " \n", + "# return model\n", + "\n", + "# # Define parameters\n", + "# tile_size = 16\n", + "# max_hits_per_tile = 5\n", + "\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + "# # Reshape midpoints for pairwise subtraction and calculate distances from reference\n", + "# midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + "# distances = tf.norm(midpoints - reference_point, axis=-1)\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# # Define the reference point (e.g., top-left corner)\n", + "# reference_point = tf.constant([0.0, 0.0], dtype=y_true.dtype)\n", + " \n", + "# # Sort both y_true and y_pred based on Euclidean distances\n", + "# y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + "# y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + "# # Create a mask for non-padded coordinates in y_true\n", + "# mask = tf.reduce_any(tf.not_equal(y_true_sorted, [0.0, 0.0]), axis=-1)\n", + " \n", + "# # Apply mask to ignore (0, 0) padded coordinates\n", + "# y_true_masked = tf.boolean_mask(y_true_sorted, mask)\n", + "# y_pred_masked = tf.boolean_mask(y_pred_sorted, mask)\n", + " \n", + "# # Ensure y_true and y_pred have the same shape after masking\n", + "# y_true_masked = tf.reshape(y_true_masked, (-1, 2))\n", + "# y_pred_masked = tf.reshape(y_pred_masked, (-1, 2))\n", + " \n", + "# # Compute the difference and power it for the custom loss\n", + "# diff = tf.abs(y_true_masked - y_pred_masked)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss\n", + "# return tf.reduce_mean(powered_diff)\n", + " \n", + "# return loss\n", + "\n", + "\n", + "\n", + "\n", + "# # Define the learning rate scheduler\n", + "# lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(\n", + "# monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6\n", + "# )\n", + "# with strategy.scope():\n", + "# # Instantiate the model\n", + "# model = build_model(tile_size=tile_size, max_hits_per_tile=max_hits_per_tile)\n", + " \n", + "# # Compile the model with the custom loss\n", + "# model.compile(optimizer='adam', loss=euclidean_sorted_custom_loss(exponent=2))\n", + "# model.summary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import h5py\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=16, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " return images, centers\n", + "\n", + " def sort_centers(self, centers):\n", + " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [hits_per_tile[i] for i in range(len(tiles))]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " \"\"\"\n", + " Pads or truncates the hit coordinates for each tile to a fixed size (max_hits_per_tile).\n", + " \"\"\"\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + " return np.array(padded_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + "\n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_centers = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_centers, train_size=train_size, random_state=random_state)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2940556/4052925944.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=16)\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # Create TensorFlow datasets for training and validation\n", + "# batch_size = 1000\n", + "# train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", + "\n", + "# train_dataset = train_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=True).batch(batch_size)\n", + "# val_dataset = val_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=False).batch(batch_size)\n", + "\n", + "# # Check the shape of the datasets\n", + "# print(f'Train Images: {train_images.shape}, Train Midpoints: {train_midpoints.shape}')\n", + "# print(f'Validation Images: {val_images.shape}, Validation Midpoints: {val_midpoints.shape}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + "\n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images and centers\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile * 2) # Flatten hit locations\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "# Flatten the training and validation datasets\n", + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=16, max_hits_per_tile=5)\n", + "val_images_flat, val_centers_flat = flatten_dataset(val_images, val_midpoints, tile_size=16, max_hits_per_tile=5)\n", + "\n", + "# Create TensorFlow datasets from the flattened data\n", + "batch_size = 1000\n", + "train_dataset_flat = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "val_dataset_flat = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(128000, 16, 16, 1)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images_flat.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t = np.random.randint(0, 8000)\n", + "u = np.random.randint(0, 4)\n", + "plt.imshow(train_images[t][u], cmap='gray') \n", + "plt.scatter(train_midpoints[t][u][:, 0] * 16, train_midpoints[t][u][:, 1] * 16, c='red')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "\n", + "def visualize_random_tiles(dataset, tile_size=16, max_hits_per_tile=5, image_count=1):\n", + " \"\"\"\n", + " Visualizes a specified number of random tiled images from the TensorFlow dataset with hit locations.\n", + "\n", + " Parameters:\n", + " - dataset: tf.data.Dataset, the dataset to visualize (train or val).\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_tile: int, the maximum number of hits per tile.\n", + " - image_count: int, the number of random images to visualize from the dataset.\n", + " \"\"\"\n", + " # Take one batch from the dataset\n", + " for images, centers in dataset.take(1):\n", + " images_np = images.numpy() # Shape: (num_tiles * num_images, tile_size, tile_size, 1)\n", + " centers_np = centers.numpy() # Shape: (num_tiles * num_images, max_hits_per_tile * 2)\n", + " \n", + " # Determine the number of images in the batch\n", + " num_images = images_np.shape[0] // 16 # Assuming 16 tiles per image for a 4x4 grid\n", + " \n", + " # Select random image indices\n", + " random_indices = random.sample(range(num_images), min(image_count, num_images))\n", + "\n", + " # Visualize the selected random images\n", + " for img_idx in random_indices:\n", + " fig, axs = plt.subplots(4, 4, figsize=(8, 8))\n", + " fig.suptitle(f\"Tiled Image with Electron Hits (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " tile_image = images_np[img_idx * 16 + tile_idx].reshape(tile_size, tile_size)\n", + " tile_centers = centers_np[img_idx * 16 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Plot the tile image\n", + " ax.imshow(tile_image, cmap='gray')\n", + "\n", + " # Plot valid hits\n", + " for (x, y) in tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='x', s=30)\n", + "\n", + " ax.axis('on')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:45:00.911052: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" + ] + } + ], + "source": [ + "visualize_random_tiles(val_dataset_flat, tile_size=16, max_hits_per_tile=5, image_count=2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((8000, 16, 16, 16), (8000, 16, 5, 2), (2000, 16, 16, 16), (2000, 16, 5, 2))" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, train_midpoints.shape, val_images.shape, val_midpoints.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "def build_model(tile_size=16, max_hits_per_tile=5):\n", + " \"\"\"\n", + " Builds a CNN model for predicting electron hit coordinates in each tile.\n", + "\n", + " Parameters:\n", + " - tile_size: int, the size of each tile (e.g., 8x8).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + "\n", + " Returns:\n", + " - model: tf.keras.Model, the compiled TensorFlow model.\n", + " \"\"\"\n", + " \n", + " output_units = max_hits_per_tile * 2 \n", + "\n", + " \n", + " x_input = layers.Input(shape=(tile_size, tile_size, 1))\n", + " x = layers.Conv2D(512, kernel_size=5, activation='relu')(x_input)\n", + " x = layers.MaxPooling2D()(x)\n", + " x = layers.Conv2D(256, kernel_size=3, activation='relu')(x)\n", + " # x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " \n", + " x = layers.Flatten()(x)\n", + " x = layers.Dense(128, activation='relu')(x)\n", + " x = layers.Dense(64, activation='relu')(x)\n", + " x_midpoints = layers.Dense(output_units, activation='sigmoid',name='x_midpoints')(x)\n", + " model = tf.keras.Model(x_input, x_midpoints)\n", + " \n", + " \n", + " \n", + " return model\n", + "\n", + "# Define parameters\n", + "tile_size = 16\n", + "max_hits_per_tile = 5\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + " # Reshape midpoints for pairwise subtraction and calculate distances from reference\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " distances = tf.norm(midpoints - reference_point, axis=-1)\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = tf.constant([0.0, 0.0], dtype=y_true.dtype)\n", + " \n", + " # Sort both y_true and y_pred based on Euclidean distances\n", + " y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + " y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + " # Create a mask for non-padded coordinates in y_true\n", + " mask = tf.reduce_any(tf.not_equal(y_true_sorted, [0.0, 0.0]), axis=-1)\n", + " \n", + " # Apply mask to ignore (0, 0) padded coordinates\n", + " y_true_masked = tf.boolean_mask(y_true_sorted, mask)\n", + " y_pred_masked = tf.boolean_mask(y_pred_sorted, mask)\n", + " \n", + " # Ensure y_true and y_pred have the same shape after masking\n", + " y_true_masked = tf.reshape(y_true_masked, (-1, 2))\n", + " y_pred_masked = tf.reshape(y_pred_masked, (-1, 2))\n", + " \n", + " # Compute the difference and power it for the custom loss\n", + " diff = tf.abs(y_true_masked - y_pred_masked)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Define the learning rate scheduler\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(\n", + " monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 16, 16, 1)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 12, 12, 512)    │        13,312 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 6, 6, 512)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 4, 4, 256)      │     1,179,904 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 4096)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │       524,416 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 64)             │         8,256 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ x_midpoints (Dense)             │ (None, 10)             │           650 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m13,312\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,179,904\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4096\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m524,416\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m8,256\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ x_midpoints (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m650\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 1,726,538 (6.59 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m1,726,538\u001b[0m (6.59 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 1,726,538 (6.59 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m1,726,538\u001b[0m (6.59 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with strategy.scope():\n", + " # Instantiate the model\n", + " model = build_model(tile_size=tile_size, max_hits_per_tile=max_hits_per_tile)\n", + " \n", + "# Compile the model with the custom loss\n", + " model.compile(optimizer='adam', loss=euclidean_sorted_custom_loss(exponent=2))\n", + " model.summary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:45:18.027940: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-09 22:45:18.035871: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-09 22:45:18.045206: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731192318.091461 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.096832 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.096889 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.136888 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.136905 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.136921 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.147764 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.147877 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.148040 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.148265 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.148389 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.148754 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.148760 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.148927 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.149175 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.149398 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.149403 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.149597 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.149765 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.149892 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.150186 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.151850 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.151849 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.151982 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.154035 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.154143 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.154261 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.156102 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.156136 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.156236 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.166223 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.166243 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.166337 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.168738 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.168743 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.168879 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.186848 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.186965 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.187049 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.189125 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.189187 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.189218 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.191283 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.191291 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.191430 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.193808 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.193839 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.193943 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 32/4000\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m6s\u001b[0m 2ms/step " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731192318.284601 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.284683 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.284689 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.290393 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.290396 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.290409 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.290956 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.291024 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.291076 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.291452 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.291638 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.291656 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.291881 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.292181 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.292201 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.292445 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.292794 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.292813 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.293026 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.293498 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.293527 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.293603 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.294021 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.294041 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.294165 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.294747 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.294759 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.296296 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.296373 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.296387 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.297174 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.297260 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.297274 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.297973 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.298151 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.298166 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.298652 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.298952 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.298965 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.299676 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.300212 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.300226 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.300966 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.301743 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.301756 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.303124 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.304081 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.304425 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.304933 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.305139 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.305152 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.306826 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.306938 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.306971 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.307279 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.307379 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.307461 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.309159 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.309159 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.309174 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.309694 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.309769 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.309783 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.311507 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.311504 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.311519 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.312060 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.312064 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.312083 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.312589 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.312662 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.312676 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.313233 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.313242 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.313349 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.313611 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.313709 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.313843 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.314137 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.314350 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.314382 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.314658 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.314941 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.314952 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.340958 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.340990 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.341072 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.341604 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.341623 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.341638 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.342261 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.342270 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.342288 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.342886 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.342954 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.342969 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.350031 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.350056 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.350061 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.352018 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.352032 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.352039 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.352698 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.352701 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.352712 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.354514 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.354532 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.354544 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.355277 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.355296 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.355307 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.356059 2940963 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.356082 2940956 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192318.356090 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4000/4000\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 1ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:45:23.416060: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-09 22:45:23.416155: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1000/1000\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 1ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:45:25.804072: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + } + ], + "source": [ + "train_outputs = model.predict(train_images_flat)\n", + "val_outputs = model.predict(val_images_flat)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "ename": "InvalidArgumentError", + "evalue": "cannot compute Sub as input #1(zero-based) was expected to be a double tensor but is a float tensor [Op:Sub] name: ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mInvalidArgumentError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m loss\u001b[38;5;241m=\u001b[39meuclidean_sorted_custom_loss(exponent\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m tl \u001b[38;5;241m=\u001b[39m\u001b[43mloss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_outputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mtrain_centers_flat\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m vl \u001b[38;5;241m=\u001b[39m loss(val_outputs,val_centers_flat)\n\u001b[1;32m 5\u001b[0m tl,vl\n", + "Cell \u001b[0;32mIn[10], line 17\u001b[0m, in \u001b[0;36meuclidean_sorted_custom_loss..loss\u001b[0;34m(y_true, y_pred)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;66;03m# Sort both y_true and y_pred based on Euclidean distances\u001b[39;00m\n\u001b[1;32m 16\u001b[0m y_true_sorted \u001b[38;5;241m=\u001b[39m sort_midpoints_by_distance(y_true, reference_point)\n\u001b[0;32m---> 17\u001b[0m y_pred_sorted \u001b[38;5;241m=\u001b[39m \u001b[43msort_midpoints_by_distance\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_pred\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreference_point\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# Create a mask for non-padded coordinates in y_true\u001b[39;00m\n\u001b[1;32m 20\u001b[0m mask \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mreduce_any(tf\u001b[38;5;241m.\u001b[39mnot_equal(y_true_sorted, [\u001b[38;5;241m0.0\u001b[39m, \u001b[38;5;241m0.0\u001b[39m]), axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\n", + "Cell \u001b[0;32mIn[10], line 6\u001b[0m, in \u001b[0;36meuclidean_sorted_custom_loss..sort_midpoints_by_distance\u001b[0;34m(midpoints, reference_point)\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msort_midpoints_by_distance\u001b[39m(midpoints, reference_point\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m0.0\u001b[39m, \u001b[38;5;241m0.0\u001b[39m)):\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Reshape midpoints for pairwise subtraction and calculate distances from reference\u001b[39;00m\n\u001b[1;32m 5\u001b[0m midpoints \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mreshape(midpoints, (\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, tf\u001b[38;5;241m.\u001b[39mshape(midpoints)[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m2\u001b[39m))\n\u001b[0;32m----> 6\u001b[0m distances \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mnorm(\u001b[43mmidpoints\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mreference_point\u001b[49m, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 7\u001b[0m sorted_indices \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39margsort(distances, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 8\u001b[0m sorted_midpoints \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mgather(midpoints, sorted_indices, batch_dims\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/util/traceback_utils.py:153\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[0;32m--> 153\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/framework/ops.py:5983\u001b[0m, in \u001b[0;36mraise_from_not_ok_status\u001b[0;34m(e, name)\u001b[0m\n\u001b[1;32m 5981\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mraise_from_not_ok_status\u001b[39m(e, name) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m NoReturn:\n\u001b[1;32m 5982\u001b[0m e\u001b[38;5;241m.\u001b[39mmessage \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m name: \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(name \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m-> 5983\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_status_to_exception(e) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[0;31mInvalidArgumentError\u001b[0m: cannot compute Sub as input #1(zero-based) was expected to be a double tensor but is a float tensor [Op:Sub] name: " + ] + } + ], + "source": [ + "loss=euclidean_sorted_custom_loss(exponent=2)\n", + "tl =loss(train_outputs,train_centers_flat)\n", + "vl = loss(val_outputs,val_centers_flat)\n", + "\n", + "tl,vl" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731192371.812115 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.812127 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.812289 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.813674 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.813753 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.813814 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.814724 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.814736 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.814770 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.815665 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.815732 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.815762 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.816591 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.816611 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.816736 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.826778 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.826869 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.827031 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.827940 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.828180 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.828211 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.828603 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.829100 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.829168 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.829315 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.829989 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.830061 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.830202 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.830879 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.830921 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.834208 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.834277 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.834300 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.835269 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.835337 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.835359 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.836377 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.836454 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.836472 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.838026 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.838106 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.838122 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.839207 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.839282 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.839297 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.840560 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.840633 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.840662 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.842514 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.842580 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.842603 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.844934 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.844999 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.845018 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.847039 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.847113 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.847130 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.891427 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.891914 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.892427 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.892828 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.893980 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.895100 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.896254 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.897458 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.898651 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.900051 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.901565 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.914283 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.914710 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.915126 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.915521 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.915980 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.916419 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.916861 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.917294 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.917749 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.918198 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.918679 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.919156 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.919659 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.920195 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.920746 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.921382 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.921986 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.922751 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.925644 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.926922 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.928227 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.929505 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192371.939949 2940958 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.090089 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.092076 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.094078 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.094614 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.095125 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.095658 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.096186 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.098370 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.098920 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.099437 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.101551 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.102101 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.102651 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.103294 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.103821 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.104365 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.105032 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.106135 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.109452 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.112676 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.115029 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.121245 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.132825 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.154696 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.155195 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.155716 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.156122 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.157272 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.158391 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.159544 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.160754 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.161957 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.163364 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.164919 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.170449 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.171032 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.171577 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.172105 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.172649 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.174971 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.177218 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.177745 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.178180 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.178763 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.179159 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.179259 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.179968 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.179982 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.180432 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.180650 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.180894 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.181330 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.181920 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.182436 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.182539 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.183258 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.183272 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.183779 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.183980 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.184306 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.184816 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.184923 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.185476 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.186110 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.186469 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.186741 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.187234 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.187514 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.188118 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.189114 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.190452 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.191012 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.191732 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.193063 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.194358 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.195088 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.198031 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.204916 2940954 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.208749 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.209291 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.209812 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.210468 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.211646 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.212771 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.213912 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.215126 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.216337 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.217729 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.219203 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.222112 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.223590 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.224043 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.224500 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.224976 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.225455 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.225947 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.226415 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.226864 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.227319 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.227795 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.228263 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.228764 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.229232 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.229786 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.230301 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.230780 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.231263 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.231789 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.231958 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.232402 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.232946 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.233064 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.233372 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.234012 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.234366 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.234542 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.235152 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.235170 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.235607 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.235890 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.236091 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.236543 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.237023 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.237537 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.238045 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.238585 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.239140 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.239465 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.239777 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.240404 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.241155 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.241608 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.244082 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.245128 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.245443 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.246405 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.247704 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.248608 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.248994 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.251753 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.254872 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.282157 2940957 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.282167 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.283627 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.285029 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.285822 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.286266 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.286806 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.287641 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.289666 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.290305 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.292327 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.292896 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.294982 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.297173 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.300293 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.303421 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.309177 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.310402 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.311553 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.312133 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.312703 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.313483 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.314061 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.314553 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.315059 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.315320 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.315626 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.315948 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.316130 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.316646 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.317318 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.317942 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.318062 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.318534 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.318735 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.319107 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.319353 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.320040 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.320616 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.321200 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.321912 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.322652 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.323197 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.323303 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.324589 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.325871 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.326638 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.329392 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.329904 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.330808 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.331266 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.331910 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.332239 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.333837 2940937 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.338593 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.350290 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.375919 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.376502 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.377040 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.377573 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.378114 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.379011 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.379925 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.380759 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.381348 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.381994 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.382717 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.383276 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.383930 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.384634 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.385409 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.386154 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.387026 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.388013 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.389892 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.393632 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.396601 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.413526 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.414436 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.414881 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.415332 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.415804 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.416278 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.416770 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.417230 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.417672 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.418131 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.418601 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.419066 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.419547 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.420020 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.420570 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.421075 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.421550 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.422026 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.422504 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.423619 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.424329 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.424949 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.425627 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.428059 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.432097 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.438199 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.441434 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.444541 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.447404 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.447822 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.448414 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.449236 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.449756 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.450278 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.450805 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.451334 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.452206 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.452740 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.453264 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.454124 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.454652 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.455203 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.455860 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.456395 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.456940 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.457612 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.458734 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.462226 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.463567 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.464100 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.464761 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.465299 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.465794 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.465880 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.466361 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.466961 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.467764 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.467883 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.468399 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.469125 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.469690 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.470553 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.471938 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.474147 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.474802 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.477911 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.485754 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.485782 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.488939 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.489493 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.489941 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.490454 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.490921 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.491458 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.492019 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 5/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0835 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731192372.495557 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.496102 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.497378 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.498661 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.499700 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.500429 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.500883 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.501256 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.501990 2940955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.510026 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.510605 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.511143 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.511671 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.512215 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.513111 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.514030 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.514874 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.515464 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.516107 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.516807 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.517355 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.518013 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.518718 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.519494 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.520234 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.521098 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.522088 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.523960 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.527671 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.530644 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.547477 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.548390 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.548838 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.549294 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.549767 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.550236 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.550726 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.551190 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.551635 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.552094 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.552565 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.553027 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.553511 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.553981 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.554531 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.555037 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.555518 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.555998 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.556470 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.557610 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.558330 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.558953 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.559634 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.562066 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.564206 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.567513 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.570645 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.573745 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.576849 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.592398 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.592906 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.593567 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.594103 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.594540 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.595013 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.595610 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.596345 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.596963 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.597672 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.598239 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.599090 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.600464 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.603282 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.606382 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.614030 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.614533 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.615067 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.615513 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.616015 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.616476 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.617015 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.617574 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.618116 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.619387 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.620655 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.621699 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.622410 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.622863 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.623241 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192372.623973 2940947 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m125/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0375" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:46:14.104519: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731192374.969935 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.971164 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.971728 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.972413 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.973120 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.973566 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.974172 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.974597 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.975008 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.975474 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.975942 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.976378 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.976458 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.976816 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.977120 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.977338 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.977812 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.977919 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.977933 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.978423 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.978664 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.978711 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.978998 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.979380 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.979636 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.979773 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.980009 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.980284 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.980694 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.980705 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.980917 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.981205 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.981616 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.981737 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.981869 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.982532 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.982655 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.982666 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.983480 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.983582 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.983600 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.984316 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.984412 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.984430 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.985278 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.985289 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.985289 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.986097 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.986206 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.986226 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.986999 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.987018 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.987745 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.987844 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.987863 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.988222 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.988479 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.988892 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.988984 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.989149 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.989735 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.989933 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.989971 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.990391 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.990762 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.990867 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.991151 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.991419 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.991623 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.991880 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.992532 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.992546 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.992685 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.993547 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.993577 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.993680 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.994430 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.994545 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.995363 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.995384 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.995669 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.996028 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.996818 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.997055 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.997114 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.997744 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.997792 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.997965 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.998197 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.998895 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192374.999426 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.000030 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.000043 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.000607 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.000731 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.001317 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.001619 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.002109 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.002956 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.002975 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.003850 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.005026 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.005150 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.005719 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.006174 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.006552 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.006647 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.007367 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.007485 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.007614 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.007835 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.008334 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.009105 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.009243 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.010120 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.010445 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.012002 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.013780 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.015480 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.018006 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.019969 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.021614 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.022645 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.023198 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.023658 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.024169 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.024666 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.024730 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.025376 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.025495 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.026198 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.026225 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.026747 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.027245 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.027618 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.027840 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.028377 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.029234 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.029743 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.031067 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.031338 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.032814 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.033166 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.034872 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.035373 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.037568 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.037582 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.039246 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.039568 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.041204 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.046887 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.047291 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.047701 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.048108 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.048515 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.048930 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.049344 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.049775 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.050200 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.050644 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.051086 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.051512 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.051980 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.052443 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.052937 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.053468 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.054078 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.054635 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.064623 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.065160 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.065235 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.065585 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.065988 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.066580 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.066580 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.067240 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.067248 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.067907 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.067923 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.068621 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.068649 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.068725 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.069285 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.069299 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.069497 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.069972 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.069987 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.070732 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.070765 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.070835 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.071423 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.071435 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.072088 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.072101 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.072779 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.072786 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.073470 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.073482 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.074146 2940943 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.074191 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.074290 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.074673 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.074921 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.075155 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.075748 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.075894 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.076426 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.077038 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.077618 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.086341 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.088093 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.089508 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.090252 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.091243 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.091985 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.093234 2940942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731192375.094940 2940945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 21ms/step - loss: 0.0369 - val_loss: 0.0062 - learning_rate: 0.0010\n", + "Epoch 2/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 0.0048 - val_loss: 0.0041 - learning_rate: 0.0010\n", + "Epoch 3/50\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m20s\u001b[0m 163ms/step - loss: 0.0041" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:46:17.034103: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0031 - val_loss: 0.0033 - learning_rate: 0.0010\n", + "Epoch 4/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0026 - val_loss: 0.0031 - learning_rate: 0.0010\n", + "Epoch 5/50\n", + "\u001b[1m125/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0022" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:46:22.267781: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 0.0022 - val_loss: 0.0030 - learning_rate: 0.0010\n", + "Epoch 6/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0019 - val_loss: 0.0029 - learning_rate: 0.0010\n", + "Epoch 7/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 13ms/step - loss: 0.0019 - val_loss: 0.0032 - learning_rate: 0.0010\n", + "Epoch 8/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 0.0016 - val_loss: 0.0030 - learning_rate: 0.0010\n", + "Epoch 9/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 16ms/step - loss: 0.0018 - val_loss: 0.0029 - learning_rate: 0.0010\n", + "Epoch 10/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 0.0015 - val_loss: 0.0029 - learning_rate: 0.0010\n", + "Epoch 11/50\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m19s\u001b[0m 153ms/step - loss: 0.0022" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:46:32.705031: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 0.0014 - val_loss: 0.0030 - learning_rate: 0.0010\n", + "Epoch 12/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0013 - val_loss: 0.0029 - learning_rate: 0.0010\n", + "Epoch 13/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 0.0013 - val_loss: 0.0032 - learning_rate: 0.0010\n", + "Epoch 14/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0014 - val_loss: 0.0031 - learning_rate: 0.0010\n", + "Epoch 15/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0011 - val_loss: 0.0029 - learning_rate: 0.0010\n", + "Epoch 16/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 0.0010 - val_loss: 0.0028 - learning_rate: 0.0010\n", + "Epoch 17/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 9.6407e-04 - val_loss: 0.0028 - learning_rate: 0.0010\n", + "Epoch 18/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0010 - val_loss: 0.0032 - learning_rate: 0.0010\n", + "Epoch 19/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 0.0013 - val_loss: 0.0024 - learning_rate: 0.0010\n", + "Epoch 20/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0012 - val_loss: 0.0031 - learning_rate: 0.0010\n", + "Epoch 21/50\n", + "\u001b[1m125/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0011" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:46:52.887280: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 0.0011 - val_loss: 0.0023 - learning_rate: 0.0010\n", + "Epoch 22/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 9.5562e-04 - val_loss: 0.0023 - learning_rate: 0.0010\n", + "Epoch 23/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 8.2662e-04 - val_loss: 0.0028 - learning_rate: 0.0010\n", + "Epoch 24/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 8.0171e-04 - val_loss: 0.0023 - learning_rate: 0.0010\n", + "Epoch 25/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 8.3687e-04 - val_loss: 0.0025 - learning_rate: 0.0010\n", + "Epoch 26/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 7.8846e-04 - val_loss: 0.0023 - learning_rate: 0.0010\n", + "Epoch 27/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 7.8220e-04 - val_loss: 0.0026 - learning_rate: 0.0010\n", + "Epoch 28/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 8.4068e-04 - val_loss: 0.0024 - learning_rate: 0.0010\n", + "Epoch 29/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 9.0890e-04 - val_loss: 0.0024 - learning_rate: 0.0010\n", + "Epoch 30/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 0.0011 - val_loss: 0.0024 - learning_rate: 0.0010\n", + "Epoch 31/50\n", + "\u001b[1m124/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0012\n", + "Epoch 31: ReduceLROnPlateau reducing learning rate to 0.0009000000427477062.\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 0.0012 - val_loss: 0.0026 - learning_rate: 0.0010\n", + "Epoch 32/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 9.3534e-04 - val_loss: 0.0023 - learning_rate: 9.0000e-04\n", + "Epoch 33/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 13ms/step - loss: 7.8340e-04 - val_loss: 0.0023 - learning_rate: 9.0000e-04\n", + "Epoch 34/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 8.3316e-04 - val_loss: 0.0022 - learning_rate: 9.0000e-04\n", + "Epoch 35/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 15ms/step - loss: 6.5537e-04 - val_loss: 0.0023 - learning_rate: 9.0000e-04\n", + "Epoch 36/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 6.4048e-04 - val_loss: 0.0023 - learning_rate: 9.0000e-04\n", + "Epoch 37/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 4.9973e-04 - val_loss: 0.0023 - learning_rate: 9.0000e-04\n", + "Epoch 38/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 6.1201e-04 - val_loss: 0.0025 - learning_rate: 9.0000e-04\n", + "Epoch 39/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 6.6298e-04 - val_loss: 0.0023 - learning_rate: 9.0000e-04\n", + "Epoch 40/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 17ms/step - loss: 6.3688e-04 - val_loss: 0.0029 - learning_rate: 9.0000e-04\n", + "Epoch 41/50\n", + "\u001b[1m125/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 7.4615e-04\n", + "Epoch 41: ReduceLROnPlateau reducing learning rate to 0.0008100000384729356.\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 7.4916e-04 - val_loss: 0.0023 - learning_rate: 9.0000e-04\n", + "Epoch 42/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 7.9993e-04 - val_loss: 0.0026 - learning_rate: 8.1000e-04\n", + "Epoch 43/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-09 22:47:33.363630: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 6.1487e-04 - val_loss: 0.0026 - learning_rate: 8.1000e-04\n", + "Epoch 44/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 11ms/step - loss: 8.0465e-04 - val_loss: 0.0024 - learning_rate: 8.1000e-04\n", + "Epoch 45/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 5.2514e-04 - val_loss: 0.0023 - learning_rate: 8.1000e-04\n", + "Epoch 46/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 17ms/step - loss: 4.5243e-04 - val_loss: 0.0023 - learning_rate: 8.1000e-04\n", + "Epoch 47/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 5.0677e-04 - val_loss: 0.0024 - learning_rate: 8.1000e-04\n", + "Epoch 48/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 5.6663e-04 - val_loss: 0.0021 - learning_rate: 8.1000e-04\n", + "Epoch 49/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 14ms/step - loss: 4.6117e-04 - val_loss: 0.0025 - learning_rate: 8.1000e-04\n", + "Epoch 50/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 13ms/step - loss: 4.7570e-04 - val_loss: 0.0024 - learning_rate: 8.1000e-04\n" + ] + } + ], + "source": [ + "# Train the model with the flattened dataset\n", + "history = model.fit(\n", + " train_dataset_flat,\n", + " validation_data=val_dataset_flat,\n", + " epochs=50, \n", + " batch_size=batch_size,callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Final Electron counting project/Post Training Analysis/40KFixed_Mixed_5_16by16_95indexNoNoiseTiled.keras')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For visualisation" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " return reconstructed_image\n", + "\n", + "def filter_predictions(predictions, threshold=0.5):\n", + " # Remove predictions close to (0,0) by applying a threshold\n", + " return [(x, y) for (x, y) in predictions if (x**2 + y**2) > threshold**2]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_predictions_without_confidence(model, dataset, tile_size=16, max_hits_per_tile=5, num_images=1, threshold=0.5):\n", + " \"\"\"\n", + " Visualizes the model's predictions on a random sample of images from the dataset,\n", + " showing both the original image and tiled predictions without confidence filtering.\n", + "\n", + " Parameters:\n", + " - model: tf.keras.Model, the trained model to make predictions.\n", + " - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - num_images: int, number of random images to visualize.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \"\"\"\n", + " # Take one batch from the dataset for prediction\n", + " images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + " # Randomly select indices of images to visualize\n", + " indices = random.sample(range(images.shape[0] // 16), num_images) # 16 tiles per image for a 4x4 grid\n", + "\n", + " # Make predictions on the batch\n", + " predictions = model.predict(images)\n", + "\n", + " # Visualize the selected images\n", + " for img_idx in indices:\n", + " # Reconstruct the original image from tiles\n", + " tiles = images[img_idx * 16 : (img_idx + 1) * 16]\n", + " reconstructed_image = reconstruct_image_from_tiles(tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 4) # 4x4 grid\n", + "\n", + " # Plot the original image with overlayed predictions\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(6, 6))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + " # Overlay true and predicted centers on the original image\n", + " for tile_idx in range(16): # 4x4 grid, 16 tiles per image\n", + " row_offset = (tile_idx // 4) * tile_size\n", + " col_offset = (tile_idx % 4) * tile_size\n", + "\n", + " # Get true and predicted centers for each tile\n", + " true_tile_centers = true_centers[img_idx * 16 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 16 + tile_idx].reshape(max_hits_per_tile, 2) # (x, y)\n", + "\n", + " # Plot true hits in green\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted hits in red, with threshold filtering\n", + " for (x, y) in filter_predictions(predicted_tile_centers, threshold=threshold):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + " # Now plot the 4x4 tiled images with predictions and true hits\n", + " fig, axs = plt.subplots(4, 4, figsize=(10, 10))\n", + " fig.suptitle(f\"Tiled Predictions and True Hits (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " true_tile_centers = true_centers[img_idx * 16 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 16 + tile_idx].reshape(max_hits_per_tile, 2) # (x, y)\n", + "\n", + " # Display the tile\n", + " ax.imshow(images[img_idx * 16 + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + " # Plot true centers\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted centers with threshold filtering\n", + " for (x, y) in filter_predictions(predicted_tile_centers, threshold=threshold):\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " ax.axis('off')\n", + "\n", + " handles, labels = axs[0, 0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'visualize_predictions_without_confidence' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Example usage with tile_size=16\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mvisualize_predictions_without_confidence\u001b[49m(model, val_dataset_flat, tile_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m16\u001b[39m, max_hits_per_tile\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m, num_images\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'visualize_predictions_without_confidence' is not defined" + ] + } + ], + "source": [ + "# Example usage with tile_size=16\n", + "visualize_predictions_without_confidence(model, val_dataset_flat, tile_size=16, max_hits_per_tile=5, num_images=2)\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/All notebooks for Tiles/Using HuggingFace Model.ipynb b/All notebooks for Tiles/Using HuggingFace Model.ipynb new file mode 100644 index 0000000..e715fb7 --- /dev/null +++ b/All notebooks for Tiles/Using HuggingFace Model.ipynb @@ -0,0 +1,5384 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'tensorflow'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mos\u001b[39;00m\n\u001b[1;32m 2\u001b[0m os\u001b[38;5;241m.\u001b[39menviron[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCUDA_VISIBLE_DEVICES\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m0,2\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;66;03m# Only GPUs 0 and 1 will be visible to TensorFlow\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mtensorflow\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mtf\u001b[39;00m\n\u001b[1;32m 5\u001b[0m strategy \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mdistribute\u001b[38;5;241m.\u001b[39mMirroredStrategy(devices\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/gpu:0\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/gpu:2\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])\u001b[39;00m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'tensorflow'" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + " val_images_flat = val_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + "\n", + " # Flatten centers to match tiles\n", + " train_centers_flat = train_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + " val_centers_flat = val_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # Create TensorFlow datasets\n", + " batch_size = 2000 \n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_200_256by256_95indexNoNoise.h5'###### used this for my work on November 23\n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " \"\"\"\n", + " Create a model that predicts hit locations for individual tiles.\n", + " \n", + " Parameters:\n", + " - input_shape: shape of the input tile (e.g., (8, 8, 1)).\n", + " - max_hits: maximum number of hits per tile (e.g., 2).\n", + "\n", + " Returns:\n", + " - model: The Keras model.\n", + " \"\"\"\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional and pooling layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + "\n", + " # Final dense layer for predictions\n", + " outputs = layers.Dense(max_hits * 2,activation='sigmoid')(x)\n", + "\n", + " # Reshape output to match the target structure per tile\n", + " outputs = layers.Reshape((max_hits, 2))(outputs)\n", + "\n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((8000, 1024, 8, 8),\n", + " (2000, 1024, 8, 8),\n", + " (8000, 1024, 2, 2),\n", + " (2000, 1024, 2, 2))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape (Reshape)               │ (None, 2, 2)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='mse')\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:01:44.316831: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "2024-11-25 18:01:46.395384: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-25 18:01:46.405100: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1732575706.500433 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.504497 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.539082 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.539250 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.539537 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.539763 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.544814 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.545035 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.560649 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.560756 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.562652 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.562779 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.563314 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.563551 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.563763 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.564005 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.565495 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.565698 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.581285 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.581539 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.581709 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.581944 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582109 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582338 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582505 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582718 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582904 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.583126 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.583295 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.583510 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.584932 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.585141 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.586650 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.586768 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.588225 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.588437 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.589953 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.590159 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.591513 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.591746 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.593408 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.593630 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.593825 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.594044 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.595212 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.595326 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.602111 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.602218 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.603722 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.603930 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.679836 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.680175 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.680418 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.680773 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.681428 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.681465 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682075 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682275 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682453 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682611 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682927 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683100 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683403 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683479 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683726 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683973 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.684265 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.684336 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.684537 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.684776 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685210 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685423 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685523 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685892 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685979 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.686154 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.686554 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.687149 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.687453 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.687638 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.687818 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.688000 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.688182 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.688338 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.689515 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.689592 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.689927 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690006 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690347 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690362 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690731 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690812 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.691976 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.692054 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.692354 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.692453 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.698635 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.698708 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699016 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699118 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699355 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699526 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699729 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699882 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.700218 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.700385 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.700721 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.700966 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.703227 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.703466 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.704340 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.704574 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 9/4096\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m27s\u001b[0m 7ms/step - loss: 0.2304 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1732575706.970318 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.970318 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.971715 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.971721 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.973640 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.973710 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974025 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974099 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974386 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974460 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974847 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974967 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.975342 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.975348 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.975659 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.975666 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.977905 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.977979 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.978285 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.978364 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.980439 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.980515 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982186 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982281 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982468 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982585 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982765 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982939 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983107 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983289 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983466 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983667 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983872 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.984054 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.984232 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.984391 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.985667 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.985758 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.987169 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.987264 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.987471 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.987626 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.993381 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.993457 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.993770 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.993874 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.994181 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.994332 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.994972 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.995118 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.996477 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.996570 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.013415 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.013420 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.016009 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.016084 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.030204 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.030232 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.031509 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.031601 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.032061 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.032154 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.032683 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.032678 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.033835 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.033908 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.035340 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.035433 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.036062 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.036137 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.036442 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.036517 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.037079 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.037151 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.037707 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.037801 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.039285 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.039292 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.039736 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.039811 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.040110 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.040186 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.041663 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.041748 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.043108 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.043183 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.045014 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.045106 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.046683 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.046764 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.047550 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.047637 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.048584 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.048659 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.061140 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.061147 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.061679 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.061686 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.062108 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.062114 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063089 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063164 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063502 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063578 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063933 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064011 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064365 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064440 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064799 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064884 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.065166 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.065258 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.065555 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.065644 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.066248 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.066344 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.070857 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.070950 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.071312 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.071320 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.072318 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.072395 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.072847 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.072923 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.073615 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.073688 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.073945 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.074102 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.076598 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.076763 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 0.0100" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:02:16.266917: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:02:16.267069: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:02:16.779043: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "W0000 00:00:1732575736.977608 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.977645 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.978448 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.978534 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.978994 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.979076 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.979517 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.979600 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.980030 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.980110 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.980539 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.980621 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.981049 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.981128 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.981567 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.981658 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.982074 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.982152 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.986551 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.986637 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.987080 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.987176 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.987601 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.987686 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.988084 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.988181 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.988483 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.988846 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.989230 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.989468 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.989690 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990004 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990282 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990468 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990738 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990960 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.991190 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.991427 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.991661 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.991970 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.992253 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.992427 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.995736 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.995808 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.996427 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.996498 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.996943 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.997027 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.997459 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.997537 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.998088 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.998172 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.998663 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.998726 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.999174 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.999260 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.999690 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.999790 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.000226 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.000321 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.000807 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.000881 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.001422 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.001509 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.001943 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.002025 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.002468 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.002533 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.003054 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.003138 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.003710 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.003792 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.004259 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.004342 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.005573 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.005709 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.006217 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.006402 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 8ms/step - loss: 0.0100 - val_loss: 7.1061e-04 - learning_rate: 0.0010\n", + "Epoch 2/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:02:19.993148: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.1475e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:02:49.555426: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:02:49.688778: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 7.1475e-04 - val_loss: 7.0710e-04 - learning_rate: 0.0010\n", + "Epoch 3/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0729e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:03:23.310957: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0729e-04 - val_loss: 7.0463e-04 - learning_rate: 0.0010\n", + "Epoch 4/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:03:25.995820: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0442e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:03:56.968466: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0441e-04 - val_loss: 7.0421e-04 - learning_rate: 0.0010\n", + "Epoch 5/50\n", + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0309e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:04:30.703699: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0309e-04 - val_loss: 7.0269e-04 - learning_rate: 0.0010\n", + "Epoch 6/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0178e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:05:04.209486: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:05:04.318436: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0178e-04 - val_loss: 7.0256e-04 - learning_rate: 0.0010\n", + "Epoch 7/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0107e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:05:37.832506: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0107e-04 - val_loss: 7.0290e-04 - learning_rate: 0.0010\n", + "Epoch 8/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0049e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:06:11.112323: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 7.0049e-04 - val_loss: 7.0294e-04 - learning_rate: 0.0010\n", + "Epoch 9/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 6ms/step - loss: 6.9983e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:06:42.071696: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 7ms/step - loss: 6.9983e-04 - val_loss: 7.0283e-04 - learning_rate: 0.0010\n", + "Epoch 10/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9926e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:07:14.635532: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 6.9926e-04 - val_loss: 7.0286e-04 - learning_rate: 0.0010\n", + "Epoch 11/50\n", + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9897e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:07:48.329451: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 11: ReduceLROnPlateau reducing learning rate to 0.0009000000427477062.\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9897e-04 - val_loss: 7.0244e-04 - learning_rate: 0.0010\n", + "Epoch 12/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:07:50.989971: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9825e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:08:20.942430: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9825e-04 - val_loss: 7.0195e-04 - learning_rate: 9.0000e-04\n", + "Epoch 13/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9787e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:08:55.157072: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9787e-04 - val_loss: 7.0162e-04 - learning_rate: 9.0000e-04\n", + "Epoch 14/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9757e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:09:28.011379: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9757e-04 - val_loss: 7.0169e-04 - learning_rate: 9.0000e-04\n", + "Epoch 15/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9739e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:10:01.753473: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9739e-04 - val_loss: 7.0184e-04 - learning_rate: 9.0000e-04\n", + "Epoch 16/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9695e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:10:35.887172: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9695e-04 - val_loss: 7.0223e-04 - learning_rate: 9.0000e-04\n", + "Epoch 17/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9672e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:11:08.453187: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 6.9672e-04 - val_loss: 7.0253e-04 - learning_rate: 9.0000e-04\n", + "Epoch 18/50\n", + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9663e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:11:42.664170: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9663e-04 - val_loss: 7.0300e-04 - learning_rate: 9.0000e-04\n", + "Epoch 19/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9639e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:12:15.652715: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9639e-04 - val_loss: 7.0343e-04 - learning_rate: 9.0000e-04\n", + "Epoch 20/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9622e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:12:49.302067: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9622e-04 - val_loss: 7.0398e-04 - learning_rate: 9.0000e-04\n", + "Epoch 21/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9604e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:13:22.237067: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 21: ReduceLROnPlateau reducing learning rate to 0.0008100000384729356.\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9604e-04 - val_loss: 7.0414e-04 - learning_rate: 9.0000e-04\n", + "Epoch 22/50\n", + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9506e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:13:55.626178: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:13:56.072721: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9506e-04 - val_loss: 7.0493e-04 - learning_rate: 8.1000e-04\n", + "Epoch 23/50\n", + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9467e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:14:30.001112: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9467e-04 - val_loss: 7.0526e-04 - learning_rate: 8.1000e-04\n", + "Epoch 24/50\n", + "\u001b[1m4089/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9462e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:15:03.320805: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9462e-04 - val_loss: 7.0547e-04 - learning_rate: 8.1000e-04\n", + "Epoch 25/50\n", + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9412e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:15:36.483315: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9412e-04 - val_loss: 7.0571e-04 - learning_rate: 8.1000e-04\n", + "Epoch 26/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9377e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:16:10.544894: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9377e-04 - val_loss: 7.0559e-04 - learning_rate: 8.1000e-04\n", + "Epoch 27/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9319e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:16:43.530632: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9319e-04 - val_loss: 7.0660e-04 - learning_rate: 8.1000e-04\n", + "Epoch 28/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9307e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:17:17.351245: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9307e-04 - val_loss: 7.0645e-04 - learning_rate: 8.1000e-04\n", + "Epoch 29/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9262e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:17:50.209043: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9262e-04 - val_loss: 7.0717e-04 - learning_rate: 8.1000e-04\n", + "Epoch 30/50\n", + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9186e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:18:24.009464: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9186e-04 - val_loss: 7.0898e-04 - learning_rate: 8.1000e-04\n", + "Epoch 31/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9135e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:18:57.247716: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 31: ReduceLROnPlateau reducing learning rate to 0.0007290000503417104.\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9135e-04 - val_loss: 7.0974e-04 - learning_rate: 8.1000e-04\n", + "Epoch 32/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9043e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:19:29.954048: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9043e-04 - val_loss: 7.1013e-04 - learning_rate: 7.2900e-04\n", + "Epoch 33/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8989e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:20:04.154027: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8989e-04 - val_loss: 7.1156e-04 - learning_rate: 7.2900e-04\n", + "Epoch 34/50\n", + "\u001b[1m4089/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8950e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:20:36.273825: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 6.8950e-04 - val_loss: 7.1195e-04 - learning_rate: 7.2900e-04\n", + "Epoch 35/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8877e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:21:10.495541: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8877e-04 - val_loss: 7.1192e-04 - learning_rate: 7.2900e-04\n", + "Epoch 36/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8820e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:21:43.211982: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8820e-04 - val_loss: 7.1346e-04 - learning_rate: 7.2900e-04\n", + "Epoch 37/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8738e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:22:16.765805: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8738e-04 - val_loss: 7.1422e-04 - learning_rate: 7.2900e-04\n", + "Epoch 38/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8696e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:22:50.600841: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8696e-04 - val_loss: 7.1470e-04 - learning_rate: 7.2900e-04\n", + "Epoch 39/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8657e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:23:23.569169: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8657e-04 - val_loss: 7.1626e-04 - learning_rate: 7.2900e-04\n", + "Epoch 40/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8558e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:23:57.777212: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8558e-04 - val_loss: 7.1619e-04 - learning_rate: 7.2900e-04\n", + "Epoch 41/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8516e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:24:30.619844: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 41: ReduceLROnPlateau reducing learning rate to 0.0006561000715009868.\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8516e-04 - val_loss: 7.1829e-04 - learning_rate: 7.2900e-04\n", + "Epoch 42/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8387e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:25:04.575765: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8387e-04 - val_loss: 7.1641e-04 - learning_rate: 6.5610e-04\n", + "Epoch 43/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8286e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:25:38.073704: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8286e-04 - val_loss: 7.1630e-04 - learning_rate: 6.5610e-04\n", + "Epoch 44/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:25:40.797286: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8219e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:26:11.445883: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8219e-04 - val_loss: 7.1707e-04 - learning_rate: 6.5610e-04\n", + "Epoch 45/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8170e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:26:45.459640: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8170e-04 - val_loss: 7.1744e-04 - learning_rate: 6.5610e-04\n", + "Epoch 46/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8099e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:27:18.204160: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8099e-04 - val_loss: 7.1814e-04 - learning_rate: 6.5610e-04\n", + "Epoch 47/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8052e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:27:52.023395: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8051e-04 - val_loss: 7.1991e-04 - learning_rate: 6.5610e-04\n", + "Epoch 48/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.7953e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:28:23.747132: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 6.7953e-04 - val_loss: 7.1891e-04 - learning_rate: 6.5610e-04\n", + "Epoch 49/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.7944e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:28:57.858164: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.7943e-04 - val_loss: 7.1873e-04 - learning_rate: 6.5610e-04\n", + "Epoch 50/50\n", + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.7861e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:29:30.433637: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.7861e-04 - val_loss: 7.2237e-04 - learning_rate: 6.5610e-04\n" + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=50,\n", + " batch_size=1000,\n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "model.save('/home/da886/Electron Counting Tiling approach/Trained weights/10KFixed_200_256by256_95indexNoNoise_sigmoid_mse.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Electron Counting Tiling approach/Trained weights/200KFixed_100_256by256_first1500_mse and sigmoid_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 49/3840\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m3s\u001b[0m 1ms/step " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-02 11:14:20.563261: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "W0000 00:00:1733156060.667207 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.667285 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.668098 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.668122 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.668638 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.668663 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.669093 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.669166 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.669545 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.669619 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670016 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670089 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670525 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670643 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670872 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671102 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671230 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671509 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671667 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671902 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672075 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672311 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672491 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672760 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672910 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.673199 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.673352 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.673608 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.673756 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674037 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674181 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674470 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674617 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674847 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675055 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675222 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675455 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675621 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675898 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676049 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676315 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676479 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676764 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676908 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.677204 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.677329 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.677616 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.677766 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.678428 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.678512 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.678897 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.678982 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m3840/3840\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 956us/step\n", + "Predicted centers shape: (120, 1024, 2, 2)\n", + "Grouped targets shape: (120, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "# # Flatten validation images and centers\n", + "val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "# train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "# train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "\n", + "# Batch size for 8 images\n", + "batch_size = 120 * 1024 # 8 images per batch\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "# train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "# Make predictions on the validation dataset\n", + "inputs, targets = next(iter(val_dataset)) # Extract a batch\n", + "outputs = model.predict(inputs)\n", + "\n", + "# Reshape predictions and targets back to image structure\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 2)\n", + "\n", + "# Print the shapes\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\") # (batch_size // 1024, 1024, 2, 2)\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\") # (batch_size // 1024, 1024, 2, 2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 12:\n", + "Tile 0: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 4: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 5: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 6: Predicted: [[2.5060314e-01 6.2125230e-01]\n", + " [1.6710628e-08 8.0681538e-08]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 7: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[8.7523717e-01 3.8167289e-01]\n", + " [3.9516075e-07 7.6895866e-08]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 11: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[8.79141867e-01 7.49784112e-01]\n", + " [4.87319925e-17 1.29109196e-17]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 18: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 23: Predicted: [[2.4865903e-01 6.2434858e-01]\n", + " [3.8695064e-14 8.5702333e-14]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 24: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 28: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 29: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 30: Predicted: [[6.3254559e-01 1.2587267e-01]\n", + " [1.3719537e-09 1.0555828e-10]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 31: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 34: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 35: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 37: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 38: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 44: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[2.5048652e-01 4.9581537e-01]\n", + " [2.2247423e-06 5.4696679e-06]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 46: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 48: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 49: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[2.8206867e-05 3.8382447e-01]\n", + " [5.7517273e-15 5.5375822e-14]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 51: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 53: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 55: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[5.0116467e-01 8.7715721e-01]\n", + " [2.1562087e-17 2.3313819e-17]], True: [[0.5 0.875]\n", + " [0. 0. ]]\n", + "Tile 59: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 61: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 63: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 64: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 65: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 66: Predicted: [[8.7217993e-01 2.4894524e-01]\n", + " [2.8863778e-07 3.1922930e-08]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 67: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 68: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 69: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[3.9728886e-05 8.7667716e-01]\n", + " [2.7492750e-15 6.0215860e-12]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 71: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 73: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[3.6967170e-01 3.7001207e-01]\n", + " [3.2294943e-06 3.3352326e-06]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 76: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 77: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 80: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 85: Predicted: [[4.2091551e-06 7.6305664e-01]\n", + " [7.2256634e-21 7.2267182e-19]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 86: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 87: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 88: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 90: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 91: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 92: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 93: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 95: Predicted: [[8.73314738e-01 1.21971026e-01]\n", + " [3.17704456e-17 3.39339266e-19]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 96: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 98: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 99: Predicted: [[3.1420742e-03 4.9609739e-01]\n", + " [9.2912569e-07 5.9589478e-05]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 100: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[6.2480927e-01 9.0272218e-04]\n", + " [5.4396503e-07 8.2624902e-09]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 102: Predicted: [[5.0110841e-01 7.5182831e-01]\n", + " [5.4996099e-07 2.1232045e-06]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 103: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[8.7087965e-01 6.2128061e-01]\n", + " [5.2493997e-06 1.6517998e-06]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 106: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 108: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 111: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 112: Predicted: [[6.2876254e-01 3.7659714e-01]\n", + " [1.1955622e-13 2.8288109e-14]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 113: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 114: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[6.2850374e-01 4.9779031e-01]\n", + " [2.1727372e-11 1.0517137e-11]], True: [[0.625 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 118: Predicted: [[8.8086069e-01 6.2502652e-01]\n", + " [2.9353957e-17 3.9358962e-18]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 119: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 120: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[7.5147665e-01 6.1706422e-05]\n", + " [9.9940991e-14 4.6818108e-17]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 122: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 124: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 126: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 127: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[8.7039524e-01 4.9657050e-01]\n", + " [5.4976622e-06 1.2262326e-06]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 129: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[5.01869828e-04 6.03021879e-04]\n", + " [2.13671442e-12 1.39067915e-11]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 131: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[0.4580677 0.65326804]\n", + " [0.4574413 0.58535695]], True: [[0. 0.875]\n", + " [0.875 0.375]]\n", + "Tile 134: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 140: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 141: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 142: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 143: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 145: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 147: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 149: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[2.4846141e-01 8.7407380e-01]\n", + " [6.3684430e-14 3.9657999e-13]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 151: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 155: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[4.9824399e-01 7.5110126e-01]\n", + " [3.2777641e-13 6.7520642e-13]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 160: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 161: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 162: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[5.4404006e-04 3.7546444e-01]\n", + " [1.2051814e-08 6.4150203e-07]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 164: Predicted: [[0.63989687 0.5194765 ]\n", + " [0.6220644 0.47348565]], True: [[0.5 0.625]\n", + " [0.75 0.375]]\n", + "Tile 165: Predicted: [[7.5021034e-01 3.7299672e-01]\n", + " [2.5723321e-06 5.7520435e-07]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 166: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 167: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 169: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[3.6954030e-01 1.2560870e-01]\n", + " [6.4141426e-04 1.6775219e-04]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 171: Predicted: [[6.2435466e-01 6.2251163e-01]\n", + " [7.2534680e-11 8.2606373e-11]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 172: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[3.30794719e-05 1.24858186e-01]\n", + " [1.32604305e-16 2.09689062e-15]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 174: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 179: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 180: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 182: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[1.2929064e-01 8.7743336e-01]\n", + " [8.9530516e-21 1.4826615e-19]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 184: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 186: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 188: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[5.0277382e-01 6.2598670e-01]\n", + " [2.4116009e-08 3.2351515e-08]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 190: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[2.4945782e-01 2.5285539e-01]\n", + " [4.0789327e-09 4.8504996e-09]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 192: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[3.30794719e-05 1.24858186e-01]\n", + " [1.32604305e-16 2.09689062e-15]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 194: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[8.7087965e-01 6.2128061e-01]\n", + " [5.2493997e-06 1.6517998e-06]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 196: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[6.2687379e-01 1.2915131e-01]\n", + " [1.2236054e-04 1.2415225e-05]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 198: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 199: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[1.2393859e-01 4.9950731e-01]\n", + " [7.3854807e-07 8.0889831e-06]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 201: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 202: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[3.7114298e-01 5.0327200e-01]\n", + " [6.4670235e-07 1.0733629e-06]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 205: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 206: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 207: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 210: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 211: Predicted: [[4.2091551e-06 7.6305664e-01]\n", + " [7.2256634e-21 7.2267182e-19]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 212: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 213: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 214: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 215: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 216: Predicted: [[3.7056655e-01 7.4863881e-01]\n", + " [1.8702304e-09 4.9766862e-09]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 217: Predicted: [[0.66226506 0.07698739]\n", + " [0.6983214 0.0672325 ]], True: [[0.625 0.125]\n", + " [0.75 0. ]]\n", + "Tile 218: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 219: Predicted: [[2.5215873e-01 7.5172102e-01]\n", + " [8.5552697e-11 3.9774264e-10]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 220: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 222: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[2.5089476e-01 8.7780875e-01]\n", + " [2.4941734e-08 3.4284457e-07]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 225: Predicted: [[5.01869828e-04 6.03021879e-04]\n", + " [2.13671442e-12 1.39067915e-11]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 226: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 227: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 228: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 230: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 231: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 234: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 236: Predicted: [[6.2102526e-01 2.4899058e-01]\n", + " [2.1521066e-04 4.2915959e-05]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 237: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 238: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 239: Predicted: [[0.43526715 0.76473254]\n", + " [0.42426988 0.7469616 ]], True: [[0.375 0.75 ]\n", + " [0.5 0.75 ]]\n", + "Tile 240: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 241: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 242: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 244: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 245: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 246: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 247: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[2.5215873e-01 7.5172102e-01]\n", + " [8.5552697e-11 3.9774264e-10]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 249: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 253: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 254: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 255: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 257: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 258: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 259: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 262: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[1.2422500e-01 1.2733902e-01]\n", + " [2.0064499e-08 1.8320929e-08]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 264: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[2.4886039e-01 2.5244540e-01]\n", + " [3.3260326e-07 2.6307825e-07]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 266: Predicted: [[3.7823945e-01 8.7176055e-01]\n", + " [3.1127118e-11 2.4505475e-10]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 267: Predicted: [[8.7217993e-01 2.4894524e-01]\n", + " [2.8863778e-07 3.1922930e-08]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 268: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 272: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 273: Predicted: [[8.79141867e-01 7.49784112e-01]\n", + " [4.87319925e-17 1.29109196e-17]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 274: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 278: Predicted: [[3.7822327e-01 2.4915342e-01]\n", + " [6.6363150e-08 3.3251315e-08]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 279: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 280: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 281: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[0.6752565 0.47998843]\n", + " [0.68016636 0.49067408]], True: [[0.875 0.5 ]\n", + " [0.5 0.5 ]]\n", + "Tile 283: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 284: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 286: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 287: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 288: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[6.2967515e-01 8.6975658e-01]\n", + " [6.1289660e-07 2.0044629e-06]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 290: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 291: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 292: Predicted: [[2.4606220e-01 1.3069469e-01]\n", + " [3.3556193e-05 1.5154692e-05]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 293: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 294: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 295: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 296: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 297: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 298: Predicted: [[7.4926120e-01 7.3678785e-07]\n", + " [6.2000773e-08 3.2475256e-10]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 299: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 300: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 302: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 303: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 304: Predicted: [[2.8206867e-05 3.8382447e-01]\n", + " [5.7517273e-15 5.5375822e-14]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 305: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 307: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 309: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 310: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 311: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 313: Predicted: [[8.7532055e-01 3.7610188e-01]\n", + " [6.0160536e-19 3.6371070e-20]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 314: Predicted: [[4.99921560e-01 4.97585803e-01]\n", + " [1.14282876e-08 1.01964135e-08]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 315: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[1.1910531e-01 7.5485933e-01]\n", + " [2.0206304e-18 1.7182666e-17]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 317: Predicted: [[7.3645042e-06 6.3326252e-01]\n", + " [1.9430138e-18 4.7767196e-17]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 318: Predicted: [[1.1271351e-06 1.6517430e-05]\n", + " [4.4691638e-20 6.3501384e-22]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 320: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 321: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 325: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 328: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 330: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 333: Predicted: [[4.9776632e-01 1.0373959e-03]\n", + " [3.0877846e-04 6.7208011e-06]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 334: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[0.5825775 0.827289 ]\n", + " [0.45158622 0.79906225]], True: [[0.875 0.75 ]\n", + " [0.125 0.875]]\n", + "Tile 336: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 337: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 338: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 339: Predicted: [[8.73314738e-01 1.21971026e-01]\n", + " [3.17704456e-17 3.39339266e-19]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 340: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 342: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[5.1031840e-01 6.6823879e-05]\n", + " [1.1857227e-12 2.0964586e-15]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 344: Predicted: [[4.99921560e-01 4.97585803e-01]\n", + " [1.14282876e-08 1.01964135e-08]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 345: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 347: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 349: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 350: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 351: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 353: Predicted: [[3.9728886e-05 8.7667716e-01]\n", + " [2.7492750e-15 6.0215860e-12]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 354: Predicted: [[0.30954725 0.4511352 ]\n", + " [0.30811647 0.5032114 ]], True: [[0.375 0.75 ]\n", + " [0.25 0.25 ]]\n", + "Tile 355: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 356: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 362: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 365: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 366: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 367: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 369: Predicted: [[7.5646979e-01 8.7383193e-01]\n", + " [2.4418881e-17 1.5137468e-17]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 370: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 371: Predicted: [[5.1031840e-01 6.6823879e-05]\n", + " [1.1857227e-12 2.0964586e-15]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 372: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[3.7844190e-01 1.2624583e-01]\n", + " [1.1740613e-08 2.4694908e-09]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 374: Predicted: [[2.4865903e-01 6.2434858e-01]\n", + " [3.8695064e-14 8.5702333e-14]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 375: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 378: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[5.0102812e-01 2.5289038e-01]\n", + " [2.1090395e-12 4.9852640e-13]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 380: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 381: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 382: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 383: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 384: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 385: Predicted: [[6.2480927e-01 9.0272218e-04]\n", + " [5.4396503e-07 8.2624902e-09]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 386: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[3.7442595e-01 7.5275952e-01]\n", + " [3.6405586e-06 1.5372232e-05]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 388: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 389: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 393: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 395: Predicted: [[3.7823945e-01 8.7176055e-01]\n", + " [3.1127118e-11 2.4505475e-10]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 396: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 397: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 398: Predicted: [[8.7400442e-01 1.2699872e-01]\n", + " [8.2201780e-08 5.0394422e-09]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 399: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 405: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 407: Predicted: [[3.6844537e-01 3.7555537e-01]\n", + " [2.1626221e-09 1.8876078e-09]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 408: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[2.5215873e-01 7.5172102e-01]\n", + " [8.5552697e-11 3.9774264e-10]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 411: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 412: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 414: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 416: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[7.5369906e-01 4.9389994e-01]\n", + " [8.1189569e-08 2.8317295e-08]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 419: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 423: Predicted: [[1.2686120e-03 6.1855143e-01]\n", + " [2.4361670e-09 4.1626069e-07]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 424: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 425: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 429: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[4.9824399e-01 7.5110126e-01]\n", + " [3.2777641e-13 6.7520642e-13]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 437: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 441: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 443: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 449: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 451: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[6.2435466e-01 6.2251163e-01]\n", + " [7.2534680e-11 8.2606373e-11]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 453: Predicted: [[5.0017506e-01 6.2630999e-01]\n", + " [3.1102818e-09 6.7008492e-09]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 454: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 457: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 458: Predicted: [[8.7039524e-01 4.9657050e-01]\n", + " [5.4976622e-06 1.2262326e-06]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 459: Predicted: [[7.4926120e-01 7.3678785e-07]\n", + " [6.2000773e-08 3.2475256e-10]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 460: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[6.2697399e-01 4.9675447e-01]\n", + " [6.3920494e-11 4.3892005e-11]], True: [[0.625 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 462: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 466: Predicted: [[6.3254559e-01 1.2587267e-01]\n", + " [1.3719537e-09 1.0555828e-10]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 467: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 468: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 469: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 470: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 471: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 472: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 478: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 481: Predicted: [[0.7497964 0.87540257]\n", + " [0.6563525 0.8422168 ]], True: [[0.75 0.875]\n", + " [0.625 0.875]]\n", + "Tile 482: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 483: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[2.4606220e-01 1.3069469e-01]\n", + " [3.3556193e-05 1.5154692e-05]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 486: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 487: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 490: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 492: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 493: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 495: Predicted: [[2.5089476e-01 8.7780875e-01]\n", + " [2.4941734e-08 3.4284457e-07]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 496: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 497: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 499: Predicted: [[1.2929064e-01 8.7743336e-01]\n", + " [8.9530516e-21 1.4826615e-19]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 500: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 505: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 507: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 509: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[1.2549226e-01 1.6036544e-04]\n", + " [4.0374859e-15 5.7697416e-17]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 512: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 513: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 517: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[2.4886039e-01 2.5244540e-01]\n", + " [3.3260326e-07 2.6307825e-07]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 519: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[5.0110841e-01 7.5182831e-01]\n", + " [5.4996099e-07 2.1232045e-06]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 522: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 523: Predicted: [[2.4886039e-01 2.5244540e-01]\n", + " [3.3260326e-07 2.6307825e-07]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 524: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 526: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 529: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 530: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 535: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 536: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 538: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 542: Predicted: [[4.9824399e-01 7.5110126e-01]\n", + " [3.2777641e-13 6.7520642e-13]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 543: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 544: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[6.2102526e-01 2.4899058e-01]\n", + " [2.1521066e-04 4.2915959e-05]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 548: Predicted: [[1.8871921e-03 2.5214130e-01]\n", + " [4.0701798e-05 6.5140077e-04]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 549: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[3.1420742e-03 4.9609739e-01]\n", + " [9.2912569e-07 5.9589478e-05]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 552: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 554: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 556: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 558: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 560: Predicted: [[5.0102812e-01 2.5289038e-01]\n", + " [2.1090395e-12 4.9852640e-13]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 561: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 562: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 563: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 565: Predicted: [[0.5450259 0.42735833]\n", + " [0.5671982 0.42094547]], True: [[0.625 0.125]\n", + " [0.5 0.75 ]]\n", + "Tile 566: Predicted: [[0.5336355 0.5800728]\n", + " [0.7114071 0.6447821]], True: [[0.375 0.375]\n", + " [0.875 0.875]]\n", + "Tile 567: Predicted: [[2.5051054e-01 5.0055176e-01]\n", + " [5.8824007e-15 8.7736503e-15]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 568: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 569: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 570: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 571: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 572: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[5.01869828e-04 6.03021879e-04]\n", + " [2.13671442e-12 1.39067915e-11]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[5.0017506e-01 6.2630999e-01]\n", + " [3.1102818e-09 6.7008492e-09]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 579: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 582: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 583: Predicted: [[8.7400442e-01 1.2699872e-01]\n", + " [8.2201780e-08 5.0394422e-09]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 584: Predicted: [[7.5369906e-01 4.9389994e-01]\n", + " [8.1189569e-08 2.8317295e-08]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 585: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[2.5089476e-01 8.7780875e-01]\n", + " [2.4941734e-08 3.4284457e-07]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 590: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 592: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 594: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[6.2734783e-01 5.9939816e-04]\n", + " [1.2920746e-10 3.5077117e-13]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 596: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 597: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 598: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[8.8086069e-01 6.2502652e-01]\n", + " [2.9353957e-17 3.9358962e-18]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 600: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 602: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 603: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 604: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 605: Predicted: [[0.4261062 0.6499689 ]\n", + " [0.27176574 0.5321187 ]], True: [[0.125 0.375]\n", + " [0.625 0.75 ]]\n", + "Tile 606: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 608: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 609: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 610: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 613: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 617: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 618: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 619: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 620: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 622: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 623: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[5.0277382e-01 6.2598670e-01]\n", + " [2.4116009e-08 3.2351515e-08]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 625: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 626: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 627: Predicted: [[2.4865903e-01 6.2434858e-01]\n", + " [3.8695064e-14 8.5702333e-14]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 628: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[8.7532055e-01 3.7610188e-01]\n", + " [6.0160536e-19 3.6371070e-20]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 633: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 634: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 635: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 641: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 642: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 643: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 645: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 647: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 648: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 649: Predicted: [[1.2131299e-01 2.2224499e-06]\n", + " [1.2624476e-07 1.3595004e-08]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 650: Predicted: [[1.2686120e-03 6.1855143e-01]\n", + " [2.4361670e-09 4.1626069e-07]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 651: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 652: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 653: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 654: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 657: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 659: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 660: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 662: Predicted: [[4.2091551e-06 7.6305664e-01]\n", + " [7.2256634e-21 7.2267182e-19]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 663: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[2.5051054e-01 5.0055176e-01]\n", + " [5.8824007e-15 8.7736503e-15]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 667: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 674: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 676: Predicted: [[7.4926120e-01 7.3678785e-07]\n", + " [6.2000773e-08 3.2475256e-10]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 677: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 679: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 688: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 693: Predicted: [[2.8206867e-05 3.8382447e-01]\n", + " [5.7517273e-15 5.5375822e-14]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 694: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 695: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 698: Predicted: [[7.5306123e-01 4.9922931e-01]\n", + " [9.3528683e-12 2.7043955e-12]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 699: Predicted: [[2.48050332e-01 7.69941980e-05]\n", + " [2.21744445e-09 1.02990715e-11]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 700: Predicted: [[8.7532055e-01 3.7610188e-01]\n", + " [6.0160536e-19 3.6371070e-20]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 701: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 705: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 706: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[4.9910015e-01 2.5150302e-01]\n", + " [9.7755083e-06 3.2932528e-06]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 708: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 710: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 711: Predicted: [[3.7230673e-01 4.5961334e-04]\n", + " [1.2089343e-04 5.2653236e-06]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 712: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 713: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 715: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 716: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 717: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 718: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[1.2288860e-01 1.2624377e-01]\n", + " [6.4002589e-15 7.1142577e-15]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 722: Predicted: [[8.80595386e-01 5.00807047e-01]\n", + " [8.48523563e-13 1.02942496e-13]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 723: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 724: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[5.0102812e-01 2.5289038e-01]\n", + " [2.1090395e-12 4.9852640e-13]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 726: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 727: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 729: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 730: Predicted: [[1.3210741e-01 6.2648559e-01]\n", + " [2.8016887e-18 1.6745299e-17]], True: [[0.125 0.625]\n", + " [0. 0. ]]\n", + "Tile 731: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 733: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 734: Predicted: [[1.2549226e-01 1.6036544e-04]\n", + " [4.0374859e-15 5.7697416e-17]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 735: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 741: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 742: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 746: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 748: Predicted: [[7.4860644e-01 2.5049281e-01]\n", + " [6.9498572e-05 1.1066318e-05]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 749: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 750: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 751: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[0.1258 0.3780244 ]\n", + " [0.12167133 0.3762547 ]], True: [[0. 0.25]\n", + " [0.25 0.5 ]]\n", + "Tile 753: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 754: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[5.0350279e-01 1.2788108e-01]\n", + " [7.6633860e-10 1.0626289e-10]], True: [[0.5 0.125]\n", + " [0. 0. ]]\n", + "Tile 756: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 760: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[4.99921560e-01 4.97585803e-01]\n", + " [1.14282876e-08 1.01964135e-08]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 764: Predicted: [[1.2929064e-01 8.7743336e-01]\n", + " [8.9530516e-21 1.4826615e-19]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 765: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 766: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[1.2357616e-05 5.1174736e-01]\n", + " [3.9506272e-12 7.3166771e-11]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 768: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 771: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 777: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 778: Predicted: [[0.64146394 0.44383013]\n", + " [0.6022558 0.42531464]], True: [[0.5 0.625]\n", + " [0.75 0.25 ]]\n", + "Tile 779: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 780: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 781: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[1.2345693e-01 5.0697517e-01]\n", + " [8.6775792e-17 3.1683688e-16]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 786: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 788: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 789: Predicted: [[1.21737674e-01 3.79419237e-01]\n", + " [1.80331959e-13 5.59754012e-13]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 790: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[3.8162413e-01 4.9975181e-01]\n", + " [8.7047844e-13 8.5942017e-13]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 792: Predicted: [[7.5264323e-01 1.2956496e-01]\n", + " [3.8601657e-11 1.4229026e-12]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 793: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 795: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 796: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 797: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 798: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 799: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 801: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 802: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[5.4404006e-04 3.7546444e-01]\n", + " [1.2051814e-08 6.4150203e-07]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 805: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 806: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 807: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 808: Predicted: [[6.7968614e-04 7.4627775e-01]\n", + " [7.8466215e-08 1.5853233e-05]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 809: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[2.48050332e-01 7.69941980e-05]\n", + " [2.21744445e-09 1.02990715e-11]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 819: Predicted: [[2.4865903e-01 6.2434858e-01]\n", + " [3.8695064e-14 8.5702333e-14]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 820: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 823: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 824: Predicted: [[5.1031840e-01 6.6823879e-05]\n", + " [1.1857227e-12 2.0964586e-15]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 825: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 829: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 830: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 832: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 836: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 838: Predicted: [[7.4926120e-01 7.3678785e-07]\n", + " [6.2000773e-08 3.2475256e-10]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 839: Predicted: [[3.6954030e-01 1.2560870e-01]\n", + " [6.4141426e-04 1.6775219e-04]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 840: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 841: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 843: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 844: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 847: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 850: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[1.1910531e-01 7.5485933e-01]\n", + " [2.0206304e-18 1.7182666e-17]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 853: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 854: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 857: Predicted: [[7.5147665e-01 6.1706422e-05]\n", + " [9.9940991e-14 4.6818108e-17]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 858: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[2.4846141e-01 8.7407380e-01]\n", + " [6.3684430e-14 3.9657999e-13]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 860: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 861: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 866: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 868: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 874: Predicted: [[3.7442595e-01 7.5275952e-01]\n", + " [3.6405586e-06 1.5372232e-05]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 875: Predicted: [[2.4969275e-01 7.5095600e-01]\n", + " [2.6954540e-06 1.5264071e-05]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 876: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[3.7529725e-01 6.2449604e-01]\n", + " [7.3330453e-09 2.1153566e-08]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 878: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 879: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 880: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[0.394082 0.26738286]\n", + " [0.34531993 0.24855323]], True: [[0. 0.125]\n", + " [0.75 0.375]]\n", + "Tile 883: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[3.7822327e-01 2.4915342e-01]\n", + " [6.6363150e-08 3.3251315e-08]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 885: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 886: Predicted: [[8.8484251e-01 8.7592053e-01]\n", + " [1.7661547e-17 5.5449159e-18]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 887: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 888: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 889: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 894: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 895: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 896: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 901: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 904: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[6.2967515e-01 8.6975658e-01]\n", + " [6.1289660e-07 2.0044629e-06]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 909: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[3.7442595e-01 7.5275952e-01]\n", + " [3.6405586e-06 1.5372232e-05]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 912: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 917: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 918: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 919: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 920: Predicted: [[6.2734783e-01 5.9939816e-04]\n", + " [1.2920746e-10 3.5077117e-13]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 921: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 922: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 923: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 924: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[0.8104064 0.3948693 ]\n", + " [0.8292201 0.38631725]], True: [[0.75 0.5 ]\n", + " [0.875 0.25 ]]\n", + "Tile 928: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 930: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 935: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 937: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 938: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 941: Predicted: [[5.0174540e-01 4.9891648e-01]\n", + " [6.6390342e-09 8.2156912e-09]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 942: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 944: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 948: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 949: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 951: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[2.4945782e-01 2.5285539e-01]\n", + " [4.0789327e-09 4.8504996e-09]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 953: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 954: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[3.7056655e-01 7.4863881e-01]\n", + " [1.8702304e-09 4.9766862e-09]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 956: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 957: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 959: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 962: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[3.7823945e-01 8.7176055e-01]\n", + " [3.1127118e-11 2.4505475e-10]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 964: Predicted: [[5.4404006e-04 3.7546444e-01]\n", + " [1.2051814e-08 6.4150203e-07]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 965: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 966: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 967: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 969: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 970: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 974: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 976: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 978: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 979: Predicted: [[0.7138456 0.77725524]\n", + " [0.76683503 0.7814397 ]], True: [[0.625 0.875]\n", + " [0.75 0.875]]\n", + "Tile 980: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 982: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 984: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 987: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 988: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[2.5215873e-01 7.5172102e-01]\n", + " [8.5552697e-11 3.9774264e-10]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 992: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 995: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 996: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1001: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1002: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1004: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1005: Predicted: [[8.7087965e-01 6.2128061e-01]\n", + " [5.2493997e-06 1.6517998e-06]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 1006: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1008: Predicted: [[7.5264323e-01 1.2956496e-01]\n", + " [3.8601657e-11 1.4229026e-12]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 1009: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[1.21737674e-01 3.79419237e-01]\n", + " [1.80331959e-13 5.59754012e-13]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 1012: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1014: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1015: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1016: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1017: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[6.0885185e-07 1.2487493e-01]\n", + " [2.1627106e-15 1.7094855e-14]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 1019: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1020: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1021: Predicted: [[1.2019656e-01 2.5231454e-01]\n", + " [7.5606145e-16 8.0718772e-16]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 1022: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1023: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "image_index = np.random.randint(0, 120) # Randomly pick an image in the batch\n", + "\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 195\n", + "False Positives (FP): 0\n", + "False Negatives (FN): 0\n", + "Precision: 1.0000, Recall: 1.0000\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.1 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1 * tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# if i in matched_true_hits:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(pred_idx)\n", + "# break\n", + "# else:\n", + "# FP += 1\n", + "\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage\n", + "tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# Plotting\n", + "fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "for i in range(4):\n", + " ax[i].imshow(tiles[i], cmap='gray')\n", + " ax[i].set_title(f\"Tile {i}\")\n", + " ax[i].axis('off')\n", + "\n", + "ax[4].imshow(reconstructed_image, cmap='gray')\n", + "ax[4].set_title(\"Reconstructed Image\")\n", + "ax[4].axis('off')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.1):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "image_index = 12 # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.05):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " - threshold: Threshold for filtering predictions.\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example usage\n", + "image_index = 0 # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for the image\n", + "\n", + "visualize_image_with_predictions(\n", + " image_tiles,\n", + " predicted_image=predicted_centers[image_index],\n", + " true_targets_image=grouped_targets[image_index],\n", + " tile_size=8,\n", + " threshold=0.2\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First image's first tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n", + "First image's second tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "for val_images, val_centers in val_dataset.take(1):\n", + " print(\"First image's first tile:\")\n", + " print(val_images[0, 0]) # Tile 0 of Image 0\n", + " print(\"First image's second tile:\")\n", + " print(val_images[0, 1]) # Tile 1 of Image 0\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Yolo5", + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/All notebooks for Tiles/Working Notebook for high Res Images.ipynb b/All notebooks for Tiles/Working Notebook for high Res Images.ipynb new file mode 100644 index 0000000..0b049ad --- /dev/null +++ b/All notebooks for Tiles/Working Notebook for high Res Images.ipynb @@ -0,0 +1,1281 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 17:59:27.741220: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-12 17:59:27.753063: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-12 17:59:27.764918: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-12 17:59:27.768500: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-12 17:59:27.778654: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-12 17:59:28.366105: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 17:59:30.049811: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 78643 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-12 17:59:30.051334: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79070 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-12 17:59:30.052722: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " \n", + " # Debug: Print the raw centers before any processing\n", + " # print(\"Raw centers for first image:\", centers[0])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " # Debug: Print hits mapped to tiles\n", + " # print(\"Mapped hits per tile for first image:\", hits_per_tile)\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # print(\"Tiled centers before padding:\", tiled_centers[0])\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) # Normalize pixel values\n", + "\n", + " # Normalize coordinates to be within the range [0, 1] based on tile size\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " # Debugging normalized and padded centers\n", + " # print(\"Normalized and padded centers for the first image:\", padded_centers[0])\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + "\n", + " # print(\"Padded centers for first image:\", padded_centers[0])\n", + " return np.array(padded_centers)\n", + " \n", + " \n", + " def reconstruct_image_from_tiles(self, tiles, tile_size, num_tiles_per_row=None):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles).\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image grid.\n", + " If None, it defaults to sqrt of the number of tiles (assuming a square layout).\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " # If num_tiles_per_row is not provided, calculate it as the square root of the number of tiles\n", + " if num_tiles_per_row is None:\n", + " num_tiles_per_row = int(np.sqrt(len(tiles)))\n", + " \n", + " # Initialize an empty array for the reconstructed image\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " \n", + " # Place each tile in the correct position in the reconstructed image\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " \n", + " return reconstructed_image\n", + " \n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + " \n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and pad if necessary\n", + " flat_centers = []\n", + " for img_centers in centers:\n", + " for tile_centers in img_centers:\n", + " # Convert tile_centers to a list of tuples to handle padding consistently\n", + " tile_centers = list(tile_centers)\n", + " if len(tile_centers) == 0:\n", + " tile_centers = [(0, 0)] * max_hits_per_tile\n", + " else:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " tile_centers = tile_centers[:max_hits_per_tile] + [(0, 0)] * (max_hits_per_tile - len(tile_centers))\n", + "\n", + " # Flatten each (x, y) hit into a single list\n", + " flat_centers.append([coord for hit in tile_centers for coord in hit])\n", + "\n", + " flat_centers = np.array(flat_centers)\n", + " return flat_images, flat_centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Instantiate DataLoader and inspect each step\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/20KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Run normalization and check the data\n", + "normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# Flatten dataset to inspect final values\n", + "train_images_flat, train_centers_flat = flatten_dataset(normalized_images, normalized_centers, tile_size=8, max_hits_per_tile=5)\n", + "# print(\"Sample flattened centers after normalization:\", train_centers_flat[:10])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "import tensorflow as tf\n", + "\n", + "# Split data into training and validation sets\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " # Normalize and flatten data from data loader\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten the dataset\n", + " train_images_flat, train_centers_flat = flatten_dataset(train_images, train_centers, tile_size=8, max_hits_per_tile=5)\n", + " val_images_flat, val_centers_flat = flatten_dataset(val_images, val_centers, tile_size=8, max_hits_per_tile=5)\n", + "\n", + " # Create TensorFlow datasets for training and validation\n", + " batch_size = 1000\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "# Generate the datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_tiles_and_centers(data_loader, img_idx=0):\n", + " \"\"\"\n", + " Visualizes an image alongside its corresponding tiles with hit centers overlaid.\n", + "\n", + " Parameters:\n", + " - data_loader: DataLoader, the instance of DataLoader to access image and center data.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " \"\"\"\n", + " # Get the image and corresponding centers\n", + " image = data_loader.images[img_idx]\n", + " centers = data_loader.centers[img_idx]\n", + " \n", + " # Tile the image and map the centers to the tiles\n", + " tiles, hits_per_tile = data_loader.map_hits_to_tiles(image, centers)\n", + " num_tiles_per_row = int(image.shape[0] / data_loader.tile_size) # Assuming square grid of tiles\n", + "\n", + " # Create a figure grid for the original image and its tiles\n", + " fig, axs = plt.subplots(num_tiles_per_row + 1, num_tiles_per_row, figsize=(12, 12))\n", + " fig.suptitle(\"Original Image and Tiles with Hit Centers\", fontsize=16)\n", + "\n", + " # Display the original image with centers\n", + " axs[0, 0].imshow(image, cmap='gray')\n", + " axs[0, 0].set_title(\"Original Image\")\n", + " axs[0, 0].axis('off')\n", + " for (_, x, y) in centers:\n", + " axs[0, 0].scatter(x, y, color='red', marker='x') # Plot hit centers on original image\n", + "\n", + " # Hide unused axes in the first row, if any\n", + " for j in range(1, num_tiles_per_row):\n", + " axs[0, j].axis('off')\n", + "\n", + " # Plot each tile with centers marked\n", + " for idx, tile in enumerate(tiles):\n", + " row = idx // num_tiles_per_row + 1\n", + " col = idx % num_tiles_per_row\n", + " axs[row, col].imshow(tile, cmap='gray')\n", + " axs[row, col].set_title(f\"Tile {idx}\")\n", + " axs[row, col].axis('on')\n", + " \n", + " # Plot centers within the tile\n", + " for (x, y) in hits_per_tile[idx]:\n", + " axs[row, col].scatter(x, y, color='red', marker='x') # Mark center within tile coordinates\n", + "\n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.9) # Adjust spacing to fit title\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "h = np.random.randint(0, 10000)\n", + "# Call the function with your DataLoader instance\n", + "visualize_image_with_tiles_and_centers(data_loader, img_idx=h) # Visualize the first image with centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:09.971836: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-12 16:38:09.979836: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-12 16:38:09.988683: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731429490.051815 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.054505 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.055210 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.108829 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.108839 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.108967 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.109431 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.109432 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.109609 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.116200 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.116267 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.116282 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.137923 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.138110 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.138119 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.140703 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.140857 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.141081 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.141516 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.141650 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.141833 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.142010 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.142204 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.142356 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.144421 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.144545 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.144625 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.165467 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.165522 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.165596 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.165825 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166300 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166316 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166319 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166898 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.166931 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167025 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167299 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167567 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167709 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.167781 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.168063 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.168170 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.168435 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.169342 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.170032 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.170202 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.170365 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.172470 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.172588 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.172671 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.175132 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.175169 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.175255 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.177461 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.177503 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.177579 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.180118 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.180294 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.180324 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.182351 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.182390 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.182465 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.182799 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.184109 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.184374 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.184457 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.192245 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.192535 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.192559 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.194659 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.194759 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.194777 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.271231 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.271572 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.271785 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.271998 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.272210 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.272421 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.272634 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.273835 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.274508 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.274729 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.275527 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.275769 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.275991 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.276213 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.278862 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.280147 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.280396 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.280616 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.280845 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.281067 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.281292 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.281519 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.283253 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.283524 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.283758 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.284393 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.284754 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.284973 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.285181 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.285393 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.285609 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.285828 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.286091 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.287632 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.288469 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.288829 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289064 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289430 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289805 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289872 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.289883 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.290473 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.290499 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.290519 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291149 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291159 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291177 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291532 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.291557 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292069 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292082 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292094 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292538 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292587 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292952 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.292970 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.293320 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.293339 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.293672 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.293967 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.294298 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.294531 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.294670 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.294906 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.295091 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.295476 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.295768 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.295863 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.296175 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.296266 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.296568 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.296680 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.297290 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.297308 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.297830 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.298109 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.298328 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.298551 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.298807 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.299035 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.299259 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.303798 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.305834 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.306076 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.308188 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.310642 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.310911 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.311484 748137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 8/512\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m3s\u001b[0m 8ms/step - loss: 0.0042 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731429490.499477 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.501218 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.501442 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.502603 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.502902 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.503610 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.503606 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.503782 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.503997 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.504435 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.504485 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.504762 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505000 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505219 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505224 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505667 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505671 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.505906 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.507560 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.507744 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.507827 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.508018 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.508259 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.508279 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.510499 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.510519 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.510540 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.517426 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.517436 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.517581 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.517880 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518101 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518116 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518549 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518671 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.518909 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519028 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519175 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519457 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519724 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519744 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.519854 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522064 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522076 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522104 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522633 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522653 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.522680 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523152 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523173 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523196 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523668 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523687 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.523714 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.524354 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.524374 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.524396 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525064 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525246 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525335 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525572 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525702 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.525722 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.527565 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.527559 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.527664 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.529434 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.529468 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.529534 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.529986 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530018 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530104 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530556 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530575 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.530648 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.531607 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.531622 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.532194 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.532703 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.532728 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.532825 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.563219 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.563356 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.563690 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.565158 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.565229 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.565641 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.566953 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.566966 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.566983 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.569386 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.569514 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.569531 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.569932 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570170 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570218 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570420 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570624 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.570708 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.572433 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.572517 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.572532 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.573887 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.573921 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.573999 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.574538 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.574569 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.574641 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.575382 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.575550 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.575577 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.577450 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.577516 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.577528 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.578458 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.578469 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.578484 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.579391 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.579459 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.579468 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.581152 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.581164 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.581178 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.582030 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.582045 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.582065 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600268 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600405 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600415 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600675 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600957 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.600981 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601196 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601464 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601490 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601701 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601946 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.601968 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.602181 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.602344 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.602360 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.603426 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.603444 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.603465 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605259 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605274 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605294 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605794 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605814 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.605891 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.606518 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.606551 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.606622 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607210 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607242 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607321 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607645 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607874 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.607897 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.608094 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.608276 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.608293 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.613912 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.613929 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.613949 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.614791 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.614811 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.614891 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615360 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615377 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615401 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615907 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615924 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.615942 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.616558 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.616576 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.616600 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.617288 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.617306 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.617325 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.618245 748146 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.618262 748140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429490.618285 748141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m508/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 9.5214e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:14.644115: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-12 16:38:14.644217: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-12 16:38:14.644340: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731429495.003241 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.003836 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.005808 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.005877 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006148 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006275 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006458 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006636 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.006844 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007026 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007206 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007390 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007565 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007742 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.007928 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.008046 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.008115 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.008754 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.008941 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009279 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009282 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009401 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009740 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009965 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.009969 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010185 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010399 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010535 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010678 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.010824 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011158 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011272 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011350 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011709 748139 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011751 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.011837 748149 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.012330 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.012634 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.013026 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.013312 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.013634 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.013915 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.014226 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.015564 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731429495.015869 748143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 10ms/step - loss: 9.4651e-04 - val_loss: 1.0308e-04\n", + "Epoch 2/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:15.608642: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m510/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 7.8845e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:19.905590: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 7.8819e-05 - val_loss: 7.5595e-05\n", + "Epoch 3/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 5.8240e-05 - val_loss: 6.6476e-05\n", + "Epoch 4/50\n", + "\u001b[1m 1/512\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:15\u001b[0m 147ms/step - loss: 2.7314e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:25.170040: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 5.1038e-05 - val_loss: 6.3451e-05\n", + "Epoch 5/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 4.7563e-05 - val_loss: 6.2155e-05\n", + "Epoch 6/50\n", + "\u001b[1m509/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 4.5338e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:38:38.791413: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 4.5354e-05 - val_loss: 6.1692e-05\n", + "Epoch 7/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 4.3514e-05 - val_loss: 6.1713e-05\n", + "Epoch 8/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 4.1651e-05 - val_loss: 6.1899e-05\n", + "Epoch 9/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 4.0144e-05 - val_loss: 6.2316e-05\n", + "Epoch 10/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 3.8541e-05 - val_loss: 6.3694e-05\n", + "Epoch 11/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 3.6841e-05 - val_loss: 6.4825e-05\n", + "Epoch 12/50\n", + "\u001b[1m 1/512\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:20\u001b[0m 158ms/step - loss: 1.7095e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:39:04.748996: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 3.5457e-05 - val_loss: 6.5911e-05\n", + "Epoch 13/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 3.3885e-05 - val_loss: 6.4922e-05\n", + "Epoch 14/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 3.2363e-05 - val_loss: 6.7580e-05\n", + "Epoch 15/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 3.0586e-05 - val_loss: 6.9048e-05\n", + "Epoch 16/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.9152e-05 - val_loss: 7.1398e-05\n", + "Epoch 17/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 2.7671e-05 - val_loss: 7.4162e-05\n", + "Epoch 18/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.6274e-05 - val_loss: 7.5322e-05\n", + "Epoch 19/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.4991e-05 - val_loss: 7.9788e-05\n", + "Epoch 20/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.4263e-05 - val_loss: 8.2104e-05\n", + "Epoch 21/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.2884e-05 - val_loss: 8.3615e-05\n", + "Epoch 22/50\n", + "\u001b[1m511/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 2.2001e-05" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:40:00.103310: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.2006e-05 - val_loss: 8.4772e-05\n", + "Epoch 23/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.1005e-05 - val_loss: 8.9697e-05\n", + "Epoch 24/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 2.0036e-05 - val_loss: 9.0401e-05\n", + "Epoch 25/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.9330e-05 - val_loss: 9.3663e-05\n", + "Epoch 26/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.9237e-05 - val_loss: 9.1168e-05\n", + "Epoch 27/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 9ms/step - loss: 1.8143e-05 - val_loss: 9.2262e-05\n", + "Epoch 28/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.7307e-05 - val_loss: 9.9012e-05\n", + "Epoch 29/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.7285e-05 - val_loss: 9.7238e-05\n", + "Epoch 30/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.6559e-05 - val_loss: 9.7413e-05\n", + "Epoch 31/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.5807e-05 - val_loss: 1.0160e-04\n", + "Epoch 32/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.5840e-05 - val_loss: 1.0242e-04\n", + "Epoch 33/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.5220e-05 - val_loss: 1.0753e-04\n", + "Epoch 34/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.5398e-05 - val_loss: 1.0038e-04\n", + "Epoch 35/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.4527e-05 - val_loss: 9.7191e-05\n", + "Epoch 36/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.4082e-05 - val_loss: 1.0286e-04\n", + "Epoch 37/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.4120e-05 - val_loss: 1.0302e-04\n", + "Epoch 38/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.4005e-05 - val_loss: 9.9109e-05\n", + "Epoch 39/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.2990e-05 - val_loss: 9.9356e-05\n", + "Epoch 40/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.3678e-05 - val_loss: 1.0106e-04\n", + "Epoch 41/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.3255e-05 - val_loss: 9.8328e-05\n", + "Epoch 42/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.2373e-05 - val_loss: 9.7759e-05\n", + "Epoch 43/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.2102e-05 - val_loss: 9.7576e-05\n", + "Epoch 44/50\n", + "\u001b[1m 1/512\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:20\u001b[0m 158ms/step - loss: 3.9487e-06" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 16:41:49.887972: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1492e-05 - val_loss: 9.7025e-05\n", + "Epoch 45/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1782e-05 - val_loss: 9.9851e-05\n", + "Epoch 46/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.2226e-05 - val_loss: 9.8247e-05\n", + "Epoch 47/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1213e-05 - val_loss: 9.6804e-05\n", + "Epoch 48/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1198e-05 - val_loss: 9.9396e-05\n", + "Epoch 49/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.1456e-05 - val_loss: 9.6983e-05\n", + "Epoch 50/50\n", + "\u001b[1m512/512\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 10ms/step - loss: 1.0804e-05 - val_loss: 1.0056e-04\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "\n", + "# Define the model\n", + "def create_model(input_shape=(8, 8, 1), max_hits=5):\n", + " model = tf.keras.Sequential([\n", + " tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + " tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(128, activation='relu'),\n", + " tf.keras.layers.Dense(max_hits * 2) # Predict x and y for each hit, so output shape is (max_hits * 2,)\n", + " ])\n", + " return model\n", + "with strategy.scope():\n", + " # Create an instance of the model\n", + " model = create_model()\n", + "\n", + " # Compile the model\n", + " model.compile(optimizer='adam', loss='mse')\n", + "\n", + "# Train the model\n", + "history = model.fit(\n", + " train_dataset, # Dataset prepared in your previous code\n", + " validation_data=val_dataset,\n", + " epochs=50,\n", + " batch_size=1000\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# loaded_model = tf.keras.models.load_model('/home/da886/Final Electron counting project/Post Training Analysis/20KFixed_Mixed_5_32by32_Tiles_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "\n", + "# def predict_and_visualize(model, data_loader, dataset, img_idx=0, tile_size=8, max_hits_per_tile=5, threshold=0.5):\n", + "# \"\"\"\n", + "# Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " \n", + "# Parameters:\n", + "# - model: Trained Keras model for prediction.\n", + "# - data_loader: DataLoader instance to access image and tile information.\n", + "# - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + "# - img_idx: int, the index of the image in the dataset to visualize.\n", + "# - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "# - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + "# \"\"\"\n", + "# # Extract image and true centers from dataset\n", + "# images, true_centers = next(iter(dataset))\n", + "# image_tiles = images[img_idx * 16: (img_idx + 1) * 16] # Assuming 16 tiles per 32x32 image\n", + " \n", + "# # Make predictions on the tiles of the chosen image\n", + "# predictions = model.predict(image_tiles)\n", + " \n", + "# # Reshape predictions for visualization\n", + "# predicted_centers = predictions.reshape(16, max_hits_per_tile, 2) # 16 tiles, each with max_hits_per_tile hits\n", + "\n", + "# # Reconstruct the original image from tiles\n", + "# reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + "# image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 4\n", + "# ) # 4x4 grid for a 32x32 image\n", + "\n", + "# # Visualize the original image with both true and filtered predicted hit centers\n", + "# fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + "# ax_orig.imshow(reconstructed_image, cmap='gray')\n", + "# ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + "# # Overlay true and filtered predicted centers on the reconstructed image\n", + "# for tile_idx in range(16): # 16 tiles for a 4x4 grid\n", + "# row_offset = (tile_idx // 4) * tile_size\n", + "# col_offset = (tile_idx % 4) * tile_size\n", + "\n", + "# # Plot true centers in green\n", + "# true_tile_centers = true_centers[img_idx *16 + tile_idx].numpy().reshape(-1, 2)\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot filtered predicted centers in red\n", + "# predicted_tile_centers = predicted_centers[tile_idx]\n", + "# for (x, y) in predicted_tile_centers:\n", + "# # Adjust the filter to be less restrictive\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): # Less strict filter\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Add legend\n", + "# handles, labels = ax_orig.get_legend_handles_labels()\n", + "# ax_orig.legend(handles, labels, loc='upper right')\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def predict_and_visualize(model, data_loader, dataset, img_idx=0, tile_size=8, max_hits_per_tile=5, threshold=0.5):\n", + " \"\"\"\n", + " Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access image and tile information.\n", + " - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + " \"\"\"\n", + " # Calculate the grid size based on the image and tile size\n", + " grid_size = 64 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + " # Extract image and true centers from dataset\n", + " images, true_centers = next(iter(dataset))\n", + "\n", + " # Adjust the indices to select the correct tiles for the image\n", + " image_tiles = images[img_idx * grid_size**2: (img_idx + 1) * grid_size**2] # 64 tiles per image\n", + "\n", + " # Make predictions on the tiles of the chosen image\n", + " predictions = model.predict(image_tiles)\n", + "\n", + " # Reshape predictions for visualization\n", + " predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + " ) # 8x8 grid for a 64x64 image\n", + "\n", + " # Visualize the original image with both true and filtered predicted hit centers\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + " # Overlay the tile boundaries\n", + " for i in range(1, grid_size):\n", + " # Horizontal lines\n", + " ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " # Vertical lines\n", + " ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true and filtered predicted centers on the reconstructed image\n", + " for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " # Plot true centers in green\n", + " true_tile_centers = true_centers[img_idx * grid_size**2 + tile_idx].numpy().reshape(-1, 2)\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='green', marker='x', s=40,\n", + " label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot filtered predicted centers in red\n", + " predicted_tile_centers = predicted_centers[tile_idx]\n", + " for (x, y) in predicted_tile_centers:\n", + " # Adjust the filter to be less restrictive\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): # Less strict filter\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='red', marker='o', s=30,\n", + " label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 227, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t = np.random.randint(0, 100)\n", + "# Example usage\n", + "predict_and_visualize(model, data_loader, train_dataset, img_idx=t)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Final Electron counting project/Post Training Analysis/20KFixed_Mixed_5_32by32_Tiles_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Analysis/Final Electron counting project Analysis copy.ipynb b/Analysis/Final Electron counting project Analysis copy.ipynb new file mode 100644 index 0000000..2800650 --- /dev/null +++ b/Analysis/Final Electron counting project Analysis copy.ipynb @@ -0,0 +1,902 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "GPU Initializing" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-05 20:11:58.462487: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-05 20:11:58.474347: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-05 20:11:58.486456: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-05 20:11:58.490039: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-05 20:11:58.500292: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-05 20:11:59.120572: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:9',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-05 20:12:02.523475: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79070 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:cf:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"9\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:9\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dependencies imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Functions and Classes" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# -----------------------------\n", + "# DataLoader Class Definition\n", + "# -----------------------------\n", + "class DataLoader:\n", + " def __init__(self, h5_filename):\n", + " self.h5_filename = h5_filename\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def plot_image_with_centers(self, image_index=None):\n", + " if image_index is None:\n", + " image_index = np.random.randint(0, len(self.images))\n", + "\n", + " image = self.images[image_index]\n", + " centers = self.centers[image_index]\n", + "\n", + " plt.imshow(image, cmap='gray')\n", + " valid_centers = centers[centers[:, 0] == 1]\n", + " for center in valid_centers:\n", + " plt.scatter(center[1], center[2], c='red', marker='x') # center[1] is x and center[2] is y\n", + " plt.title('Image with Valid Centers Marked')\n", + " plt.colorbar()\n", + " plt.show()\n", + "\n", + " @staticmethod\n", + " def sort_centers(centers):\n", + " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + " def normalize_data(self):\n", + " normalized_images = self.images / np.max(self.images)\n", + " sorted_centers = np.array([self.sort_centers(image_centers[:, 1:]) for image_centers in self.centers])\n", + " normalized_centers = sorted_centers / np.max(centers)\n", + "\n", + " normalized_midpoints = tf.expand_dims(normalized_centers, axis=1)\n", + " return normalized_images, normalized_midpoints.numpy()\n", + "\n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_midpoints_np = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_midpoints_np, train_size=train_size, random_state=random_state)\n", + " \n", + " \n", + "\n", + "# -----------------------------\n", + "# Utility Function Definition\n", + "# -----------------------------\n", + "def plot_transposed_images_with_midpoints(dataset, image_indices=[0, 1, 2, 3]):\n", + " \"\"\"\n", + " Extracts multiple images and their midpoints from the given dataset, transposes the images, \n", + " corrects the midpoints, and plots the transposed images with the corrected midpoints.\n", + "\n", + " Args:\n", + " - dataset (tf.data.Dataset): The dataset from which to extract the images and midpoints.\n", + " - image_indices (list): The indices of the images in the batch to visualize. Default is [0, 1, 2, 3].\n", + " \"\"\"\n", + "\n", + " # Extract a sample image batch and its corresponding midpoints from the dataset\n", + " sample_image_batch, sample_midpoints_batch = next(iter(dataset))\n", + "\n", + " # Create a figure with 2x2 subplots\n", + " fig, axes = plt.subplots(2, 2, figsize=(6, 6))\n", + "\n", + " for i, ax in enumerate(axes.flat):\n", + " if i < len(image_indices):\n", + " # Select the specified image and corresponding midpoints from the batch\n", + " sample_image = np.array(sample_image_batch[image_indices[i]])\n", + " sample_midpoints = np.array(sample_midpoints_batch[image_indices[i]])\n", + "\n", + " # Transpose the image\n", + " transposed_image = sample_image.T\n", + "\n", + " # Correct the midpoints by swapping the x and y coordinates\n", + " transposed_midpoints_corrected = sample_midpoints[:, :, [1, 0]]\n", + "\n", + " # Plot the transposed image with corrected midpoints\n", + " ax.imshow(transposed_image, cmap='gray')\n", + " ax.scatter(\n", + " transposed_midpoints_corrected[:, :, 0] * 63, \n", + " transposed_midpoints_corrected[:, :, 1] * 63, \n", + " c='red', marker='o', s=5\n", + " )\n", + " ax.set_title(f'Image {image_indices[i]} for this batch')\n", + " else:\n", + " ax.axis('off') # If fewer than 4 images are requested, hide the unused subplots\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# -----------------------------\n", + "# Custom Loss and Callback Definitions\n", + "# -----------------------------\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def custom_loss(exponent):\n", + " def loss(y_true, y_pred):\n", + " diff = tf.abs(y_true - y_pred)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " return tf.reduce_mean(powered_diff)\n", + " return loss\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "class DynamicExponentCallback(tf.keras.callbacks.Callback):\n", + " def __init__(self, initial_exponent, increment, update_frequency):\n", + " super().__init__()\n", + " self.exponent = initial_exponent\n", + " self.increment = increment\n", + " self.update_frequency = update_frequency\n", + "\n", + " def on_epoch_end(self, epoch, logs=None):\n", + " if (epoch + 1) % self.update_frequency == 0:\n", + " self.exponent += self.increment\n", + " print(f\"\\nEpoch {epoch + 1}: Increasing exponent to {self.exponent}\")\n", + " self.model.loss = self.custom_loss(self.exponent)\n", + "\n", + " def custom_loss(self, exponent):\n", + " def loss(y_true, y_pred):\n", + " diff = tf.abs(y_true - y_pred)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " return tf.reduce_mean(powered_diff)\n", + " return loss\n", + "\n", + " def get_config(self):\n", + " config = super().get_config().copy()\n", + " config.update({\n", + " 'initial_exponent': self.exponent,\n", + " 'increment': self.increment,\n", + " 'update_frequency': self.update_frequency,\n", + " })\n", + " return config\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data Loading" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Load data\n", + "\n", + "h5_filename ='/home/da886/Final Electron counting project/Images and Labels/40KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "# h5_filename ='/home/da886/Final Electron counting project/Images and Labels/30KFixed_Mixed_13.h5'\n", + "\n", + "data_loader = DataLoader(h5_filename)\n", + "images, centers = data_loader.load_data()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data processing I" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Normalize the data and split it into training and validation sets\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 64.0, 0.015873017, 1.0)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(train_images)*64, np.max(train_images)*64, np.min(train_midpoints), np.max(train_midpoints)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data Processing II" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Images: (32000, 64, 64), Train Midpoints: (32000, 1, 5, 2)\n", + "Validation Images: (8000, 64, 64), Validation Midpoints: (8000, 1, 5, 2)\n" + ] + } + ], + "source": [ + "\n", + "batch_size = 1000\n", + "train_dataset = train_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=True).batch(batch_size)\n", + "val_dataset = val_dataset.shuffle(buffer_size=8000).batch(batch_size)\n", + "\n", + "# Check the shape of the datasets\n", + "print(f'Train Images: {train_images.shape}, Train Midpoints: {train_midpoints.shape}')\n", + "print(f'Validation Images: {val_images.shape}, Validation Midpoints: {val_midpoints.shape}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_transposed_images_with_midpoints(train_dataset, image_indices=[0, 1, 2, 3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load Trained Weights" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "loaded_model = tf.keras.models.load_model(\n", + "\"/home/da886/Final Electron counting project/Post Training Analysis/40KFixed_Mixed_5_16by16_95indexNoNoise_Bigger model.keras\", \n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "# Define the function for visualizing midpoints\n", + "def visualize_midpoints_with_gt(image, true_midpoints, pred_midpoints, title=\"Predicted vs GT Midpoints\"):\n", + " \"\"\"\n", + " Visualizes ground truth and predicted midpoints on an image and draws lines to connect them.\n", + "\n", + " Parameters:\n", + " - image: A 3D tensor representing the image.\n", + " - true_midpoints: A 2D tensor representing the ground truth midpoint coordinates (x, y).\n", + " - pred_midpoints: A 2D tensor representing the predicted midpoint coordinates (x, y).\n", + " - title: The title of the plot.\n", + "\n", + " Returns:\n", + " None (displays the image with midpoints and lines).\n", + " \"\"\"\n", + " # Convert to NumPy arrays for easier handling\n", + " image_np = image\n", + "\n", + " # Ensure that midpoints are in the shape (num_points, 2) for both true and predicted midpoints\n", + " true_midpoints_np = np.reshape(true_midpoints, (-1, 2))\n", + " pred_midpoints_np = np.reshape(pred_midpoints, (-1, 2))\n", + "\n", + " # Visualize the image\n", + " plt.figure(figsize=(4, 4))\n", + " plt.imshow(image_np, cmap='gray')\n", + " plt.title(title)\n", + "\n", + " # Plot both ground truth and predicted midpoints\n", + " for i, ((gt_x, gt_y), (pred_x, pred_y)) in enumerate(zip(true_midpoints_np, pred_midpoints_np)):\n", + " if gt_x >= 0 and gt_y >= 0: # Only plot if the GT point is valid\n", + " plt.scatter(gt_x, gt_y, color='blue', label='Ground Truth' if i == 0 else \"\", s=30)\n", + " plt.scatter(pred_x, pred_y, color='red', label='Prediction' if i == 0 else \"\", s=30)\n", + "\n", + " # Draw a line connecting the GT and predicted points\n", + " plt.plot([gt_x, pred_x], [gt_y, pred_y], color='green', linewidth=1)\n", + "\n", + " # Add legend only once\n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing batch 1, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 2, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 3, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 4, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 5, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 6, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 7, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 8, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 9, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", + "Processing batch 10, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n" + ] + } + ], + "source": [ + "\n", + "# Create the training dataset\n", + "# train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "# train_dataset = train_dataset.batch(800)\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", + "val_dataset = val_dataset.batch(800)\n", + "# Initialize lists to collect the data\n", + "all_images = []\n", + "all_true_midpoints = []\n", + "all_pred_midpoints = []\n", + "\n", + "# Loop through each batch in the training dataset, predict, and collect results\n", + "# for i, (data_batch, midpoints_batch) in enumerate(train_dataset):\n", + "for i, (data_batch, midpoints_batch) in enumerate(val_dataset):\n", + " print(f\"Processing batch {i + 1}, batch shape: {data_batch.shape}\")\n", + " \n", + " # Get the model predictions\n", + " predictions = loaded_model.predict(data_batch)\n", + "\n", + " # Extend the lists to store data from each batch\n", + " all_images.extend(data_batch.numpy()) # Store all images\n", + " all_true_midpoints.extend(midpoints_batch.numpy()) # Store all true midpoints\n", + " all_pred_midpoints.extend(predictions) # Store all predicted midpoints\n", + "\n", + "# Convert lists to arrays for easier indexing\n", + "all_images = np.array(all_images)\n", + "all_true_midpoints = np.array(all_true_midpoints)\n", + "all_pred_midpoints = np.array(all_pred_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "index_to_visualize = np.random.randint(0, len(all_images))\n", + "# Visualize the results for the first sample (you can change the index to visualize others)\n", + "visualize_midpoints_with_gt(all_images[index_to_visualize ], all_true_midpoints[index_to_visualize ]*np.max(centers), all_pred_midpoints[index_to_visualize ]*np.max(centers))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Select an index to visualize from the entire dataset\n", + "index_to_visualize = np.random.randint(0, len(all_images))\n", + "\n", + "# index_to_visualize = 11548\n", + "# Visualize the selected image with predicted and true midpoints\n", + "visualize_midpoints(all_images[index_to_visualize], all_pred_midpoints[index_to_visualize, 0, :, :] * np.max(centers), title=\"Predicted Midpoints\")\n", + "visualize_midpoints(all_images[index_to_visualize], all_true_midpoints[index_to_visualize, 0, :, :] * np.max(centers), title=\"Ground Truth Midpoints\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1729712682.539841 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712682.549313 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712682.565178 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712682.601693 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712682.635001 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712682.697655 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712682.787367 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712682.930107 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712682.960190 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m13/13\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 18ms/step - loss: 2.5705e-05\n" + ] + }, + { + "data": { + "text/plain": [ + "2.5883311536745168e-05" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loaded_model.evaluate(train_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1729712695.873251 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712695.884775 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712695.904320 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712695.949496 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712695.990751 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.069669 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.183212 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.360693 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.393671 4076549 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/3\u001b[0m \u001b[32m━━━━━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━\u001b[0m \u001b[1m1s\u001b[0m 750ms/step - loss: 0.0255" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1729712696.626798 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.633904 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.645778 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.673013 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.697766 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.744662 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.812410 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m3/3\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 234ms/step - loss: 0.0258\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1729712696.918502 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1729712696.938507 4076548 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + } + ], + "source": [ + "val_loss = loaded_model.evaluate(val_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 64, 64, 1)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 64, 64, 64)     │         7,808 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 32, 32, 64)     │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 32, 32, 64)     │       495,680 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 32, 32, 128)    │       663,680 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (Conv2D)               │ (None, 32, 32, 128)    │     1,327,232 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (MaxPooling2D)  │ (None, 16, 16, 128)    │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_4 (Conv2D)               │ (None, 16, 16, 256)    │     1,605,888 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_5 (Conv2D)               │ (None, 16, 16, 256)    │     3,211,520 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_6 (Conv2D)               │ (None, 16, 16, 512)    │     3,277,312 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_2 (MaxPooling2D)  │ (None, 8, 8, 512)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_7 (Conv2D)               │ (None, 8, 8, 512)      │     2,359,808 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_3 (MaxPooling2D)  │ (None, 4, 4, 512)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_8 (Conv2D)               │ (None, 4, 4, 512)      │     2,359,808 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_4 (MaxPooling2D)  │ (None, 2, 2, 512)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_9 (Conv2D)               │ (None, 2, 2, 256)      │     1,179,904 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_5 (MaxPooling2D)  │ (None, 1, 1, 256)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization             │ (None, 1, 1, 256)      │         1,024 │\n",
+       "│ (BatchNormalization)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 256)            │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ x_midpoints (Dense)             │ (None, 10)             │         2,570 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ x_midpoints_reshape (Reshape)   │ (None, 1, 5, 2)        │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m7,808\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m495,680\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m663,680\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,327,232\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_4 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,605,888\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_5 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m3,211,520\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_6 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m3,277,312\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_7 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m2,359,808\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_3 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_8 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m2,359,808\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_4 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_9 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,179,904\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_5 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ batch_normalization │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,024\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ x_midpoints (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m2,570\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ x_midpoints_reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 49,475,680 (188.73 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m49,475,680\u001b[0m (188.73 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 16,491,722 (62.91 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m16,491,722\u001b[0m (62.91 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 512 (2.00 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m512\u001b[0m (2.00 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Optimizer params: 32,983,446 (125.82 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m32,983,446\u001b[0m (125.82 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "loaded_model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0158730745315552, 64.0)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(train_midpoints)*64,np.max(train_midpoints)*64" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(9.0, 54.0)" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(val_midpoints)*64,np.max(val_midpoints)*64" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6.770519256591797, 56.109825134277344)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(all_pred_midpoints)*64,np.max(all_pred_midpoints)*64" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Analysis/Final Electron counting project Analysis.ipynb b/Analysis/Final Electron counting project Analysis.ipynb new file mode 100644 index 0000000..eb81621 --- /dev/null +++ b/Analysis/Final Electron counting project Analysis.ipynb @@ -0,0 +1,1206 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "GPU Initializing" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-18 16:50:50.107873: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-18 16:50:50.119967: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-18 16:50:50.132406: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-18 16:50:50.136171: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-18 16:50:50.146439: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-18 16:50:50.768322: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:6',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-18 16:50:51.959326: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:c6:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"6\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:6\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dependencies imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Functions and Classes" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " \n", + " # Debug: Print the raw centers before any processing\n", + " # print(\"Raw centers for first image:\", centers[0])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " # Debug: Print hits mapped to tiles\n", + " # print(\"Mapped hits per tile for first image:\", hits_per_tile)\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # print(\"Tiled centers before padding:\", tiled_centers[0])\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + " def pad_hits(self, centers):\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + "\n", + " # print(\"Padded centers for first image:\", padded_centers[0])\n", + " return np.array(padded_centers)\n", + " \n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1] based on tile size\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " # Debugging normalized and padded centers\n", + " # print(\"Normalized and padded centers for the first image:\", padded_centers[0])\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + "\n", + " \n", + " def reconstruct_image_from_tiles(self, tiles, tile_size, num_tiles_per_row=None):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles).\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image grid.\n", + " If None, it defaults to sqrt of the number of tiles (assuming a square layout).\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " # If num_tiles_per_row is not provided, calculate it as the square root of the number of tiles\n", + " if num_tiles_per_row is None:\n", + " num_tiles_per_row = int(np.sqrt(len(tiles)))\n", + " \n", + " # Initialize an empty array for the reconstructed image\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " \n", + " # Place each tile in the correct position in the reconstructed image\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " \n", + " return reconstructed_image\n", + " \n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + " \n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and pad if necessary\n", + " flat_centers = []\n", + " for img_centers in centers:\n", + " for tile_centers in img_centers:\n", + " # Convert tile_centers to a list of tuples to handle padding consistently\n", + " tile_centers = list(tile_centers)\n", + " if len(tile_centers) == 0:\n", + " tile_centers = [(0, 0)] * max_hits_per_tile\n", + " else:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " tile_centers = tile_centers[:max_hits_per_tile] + [(0, 0)] * (max_hits_per_tile - len(tile_centers))\n", + "\n", + " # Flatten each (x, y) hit into a single list\n", + " flat_centers.append([coord for hit in tile_centers for coord in hit])\n", + "\n", + " flat_centers = np.array(flat_centers)\n", + " return flat_images, flat_centers\n", + "\n", + "\n", + "# Split data into training and validation sets\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " # Normalize and flatten data from data loader\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten the dataset\n", + " train_images_flat, train_centers_flat = flatten_dataset(train_images, train_centers, tile_size=8, max_hits_per_tile=5)\n", + " val_images_flat, val_centers_flat = flatten_dataset(val_images, val_centers, tile_size=8, max_hits_per_tile=5)\n", + "\n", + " # Create TensorFlow datasets for training and validation\n", + " batch_size = 1000\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data Loading" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Load data\n", + "\n", + "\n", + "\n", + "# file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/6KTestSet_5_64by64_RandomindexNoNoise.h5' \n", + "# file_path ='/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/6KTestSet_5_64by64_Randomindex.h5'\n", + "# file_path ='/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/6KTestSet_13_64by64_95indexNoNoise.h5'\n", + "file_path ='/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_Testset_100_256by256_RandomindexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# images, centers = data_loader.normalize_data()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data processing I" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Generate the datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data Processing II" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(8, 8))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort both y_true and y_pred based on Euclidean distances\n", + " y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + " y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + " # Compute the difference\n", + " diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load Trained Weights" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "loaded_model = tf.keras.models.load_model(\n", + "\"/home/da886/Electron Counting Tiling approach/Trained weights/10KFixed_Testset_100_256by256_Linear_RandomindexNoNoise.keras\", \n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "\n", + "# def predict_and_visualize(model, data_loader, dataset, img_idx, tile_size=8, max_hits_per_tile=13, threshold=0.5):\n", + "# \"\"\"\n", + "# Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + "# Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + "# Parameters:\n", + "# - model: Trained Keras model for prediction.\n", + "# - data_loader: DataLoader instance to access image and tile information.\n", + "# - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + "# - img_idx: int, the index of the image in the dataset to visualize.\n", + "# - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "# - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + "# \"\"\"\n", + "# # Calculate the grid size based on the image and tile size\n", + "# grid_size = 64 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + "# # Extract image and true centers from dataset\n", + "# images, true_centers = next(iter(dataset))\n", + "\n", + "# # Adjust the indices to select the correct tiles for the image\n", + "# image_tiles = images[img_idx * grid_size**2: (img_idx + 1) * grid_size**2] # 64 tiles per image\n", + "\n", + "# # Make predictions on the tiles of the chosen image\n", + "# predictions = model.predict(image_tiles)\n", + "\n", + "# # Reshape predictions for visualization\n", + "# predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + "# # Reconstruct the original image from tiles\n", + "# reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + "# image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + "# ) # 8x8 grid for a 64x64 image\n", + "\n", + "# # Visualize the original image with both true and filtered predicted hit centers\n", + "# fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + "# ax_orig.imshow(reconstructed_image, cmap='gray')\n", + "# ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + "# # Overlay the tile boundaries\n", + "# for i in range(1, grid_size):\n", + "# # Horizontal lines\n", + "# ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "# # Vertical lines\n", + "# ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + "# # Overlay true and filtered predicted centers on the reconstructed image\n", + "# for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + "# row_offset = (tile_idx // grid_size) * tile_size\n", + "# col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + "# # Plot true centers in green\n", + "# true_tile_centers = true_centers[img_idx * grid_size**2 + tile_idx].numpy().reshape(-1, 2)\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + "# c='green', marker='x', s=40,\n", + "# label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot filtered predicted centers in red\n", + "# predicted_tile_centers = predicted_centers[tile_idx]\n", + "# for (x, y) in predicted_tile_centers:\n", + " \n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): \n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + "# c='red', marker='o', s=30,\n", + "# label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Add legend\n", + "# handles, labels = ax_orig.get_legend_handles_labels()\n", + "# ax_orig.legend(handles, labels, loc='upper right')\n", + "# plt.show()\n", + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "# import tensorflow as tf\n", + "\n", + "# def predict_and_visualize(model, data_loader, dataset, img_idx, tile_size=8, max_hits_per_tile=13, threshold=0.5):\n", + "# \"\"\"\n", + "# Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + "# Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + "# Parameters:\n", + "# - model: Trained Keras model for prediction.\n", + "# - data_loader: DataLoader instance to access image and tile information.\n", + "# - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + "# - img_idx: int, the index of the image in the dataset to visualize.\n", + "# - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "# - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + "# \"\"\"\n", + "# # Calculate the grid size based on the image and tile size\n", + "# grid_size = 256 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + "# # Initialize variables to store the cumulative number of images processed\n", + "# cumulative_images = 0\n", + "\n", + "# # Iterate over the dataset to find the batch containing the desired image index\n", + "# for batch_images, batch_true_centers in dataset:\n", + "# # Calculate the number of images in the current batch\n", + "# num_tiles_in_batch = batch_images.shape[0]\n", + "# num_images_in_batch = num_tiles_in_batch // (grid_size ** 2)\n", + "\n", + "# # Check if the desired image is in the current batch\n", + "# if cumulative_images + num_images_in_batch > img_idx:\n", + "# # Calculate the index of the image within the batch\n", + "# batch_img_idx = img_idx - cumulative_images\n", + "\n", + "# # Extract the tiles and true centers for the desired image\n", + "# start_idx = batch_img_idx * grid_size**2\n", + "# end_idx = (batch_img_idx + 1) * grid_size**2\n", + "# image_tiles = batch_images[start_idx:end_idx]\n", + "# true_centers_tiles = batch_true_centers[start_idx:end_idx]\n", + "# break\n", + "\n", + "# cumulative_images += num_images_in_batch\n", + "# else:\n", + "# # If we exit the loop normally, the image index was out of range\n", + "# raise IndexError(f\"Image index {img_idx} is out of range.\")\n", + "\n", + "# # Make predictions on the tiles of the chosen image\n", + "# predictions = model.predict(image_tiles)\n", + "\n", + "# # Reshape predictions for visualization\n", + "# predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + "# # Reconstruct the original image from tiles\n", + "# reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + "# image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + "# ) # 8x8 grid for a 64x64 image\n", + "\n", + "# # Visualize the original image with both true and filtered predicted hit centers\n", + "# fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + "# ax_orig.imshow(reconstructed_image, cmap='gray')\n", + "# ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + "# # Overlay the tile boundaries\n", + "# for i in range(1, grid_size):\n", + "# # Horizontal lines\n", + "# ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "# # Vertical lines\n", + "# ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + "# # Overlay true and filtered predicted centers on the reconstructed image\n", + "# for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + "# row_offset = (tile_idx // grid_size) * tile_size\n", + "# col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + "# # Plot true centers in green\n", + "# true_tile_centers = true_centers_tiles[tile_idx].numpy().reshape(-1, 2)\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + "# c='green', marker='x', s=40,\n", + "# label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot filtered predicted centers in red\n", + "# predicted_tile_centers = predicted_centers[tile_idx]\n", + "# for (x, y) in predicted_tile_centers:\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size):\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + "# c='red', marker='o', s=30,\n", + "# label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Add legend\n", + "# handles, labels = ax_orig.get_legend_handles_labels()\n", + "# ax_orig.legend(handles, labels, loc='upper right')\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def predict_and_visualize(model, data_loader, dataset, img_idx, tile_size=8, max_hits_per_tile=5, threshold=1):\n", + " \"\"\"\n", + " Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access image and tile information.\n", + " - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + " \"\"\"\n", + " # Calculate the grid size based on the image and tile size\n", + " grid_size = 256 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + " # Initialize variables to store the cumulative number of images processed\n", + " cumulative_images = 0\n", + "\n", + " # Iterate over the dataset to find the batch containing the desired image index\n", + " for batch_images, batch_true_centers in dataset:\n", + " # Calculate the number of images in the current batch\n", + " num_tiles_in_batch = batch_images.shape[0]\n", + " num_images_in_batch = num_tiles_in_batch // (grid_size ** 2)\n", + "\n", + " # Check if the desired image is in the current batch\n", + " if cumulative_images + num_images_in_batch > img_idx:\n", + " # Calculate the index of the image within the batch\n", + " batch_img_idx = img_idx - cumulative_images\n", + "\n", + " # Extract the tiles and true centers for the desired image\n", + " start_idx = batch_img_idx * grid_size**2\n", + " end_idx = (batch_img_idx + 1) * grid_size**2\n", + " image_tiles = batch_images[start_idx:end_idx]\n", + " true_centers_tiles = batch_true_centers[start_idx:end_idx]\n", + " break\n", + "\n", + " cumulative_images += num_images_in_batch\n", + " else:\n", + " # If we exit the loop normally, the image index was out of range\n", + " raise IndexError(f\"Image index {img_idx} is out of range.\")\n", + "\n", + " # Make predictions on the tiles of the chosen image\n", + " predictions = model.predict(image_tiles)\n", + "\n", + " # Reshape predictions for visualization\n", + " predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + " ) # 8x8 grid for a 64x64 image\n", + "\n", + " # Visualize the original image with both true and filtered predicted hit centers\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(15, 15))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + " # Overlay the tile boundaries\n", + " for i in range(1, grid_size):\n", + " # Horizontal lines\n", + " ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " # Vertical lines\n", + " ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true and filtered predicted centers on the reconstructed image\n", + " for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " # Plot true centers in green\n", + " true_tile_centers = true_centers_tiles[tile_idx].numpy().reshape(-1, 2)\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='green', marker='x', s=40,\n", + " label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot filtered predicted centers in red\n", + " predicted_tile_centers = predicted_centers[tile_idx]\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='red', marker='o', s=30,\n", + " label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "Image index 2 is out of range.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[18], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m t \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m100\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m \u001b[43mpredict_and_visualize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloaded_model\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimg_idx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[15], line 46\u001b[0m, in \u001b[0;36mpredict_and_visualize\u001b[0;34m(model, data_loader, dataset, img_idx, tile_size, max_hits_per_tile, threshold)\u001b[0m\n\u001b[1;32m 43\u001b[0m cumulative_images \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m num_images_in_batch\n\u001b[1;32m 44\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 45\u001b[0m \u001b[38;5;66;03m# If we exit the loop normally, the image index was out of range\u001b[39;00m\n\u001b[0;32m---> 46\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mImage index \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mimg_idx\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is out of range.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 48\u001b[0m \u001b[38;5;66;03m# Make predictions on the tiles of the chosen image\u001b[39;00m\n\u001b[1;32m 49\u001b[0m predictions \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mpredict(image_tiles)\n", + "\u001b[0;31mIndexError\u001b[0m: Image index 2 is out of range." + ] + } + ], + "source": [ + "t = np.random.randint(0, 100)\n", + "predict_and_visualize(loaded_model, data_loader, val_dataset, img_idx=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"sequential_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 6, 6, 256)      │         2,560 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (MaxPooling2D)  │ (None, 3, 3, 256)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (Conv2D)               │ (None, 1, 1, 64)       │       147,520 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (Flatten)             │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (Dense)                 │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (Dense)                 │ (None, 10)             │         1,290 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m2,560\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m147,520\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m1,290\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 479,072 (1.83 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m479,072\u001b[0m (1.83 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 159,690 (623.79 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m159,690\u001b[0m (623.79 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Optimizer params: 319,382 (1.22 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m319,382\u001b[0m (1.22 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "loaded_model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 773us/step\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqAAAAKqCAYAAADlp+yjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9fXxVV5n3j793CE15KIhY2jSFVECRijLYGAcplqkCI+DEDPnlhskviHFoOpkIAoUij4GSCLQFqRFBpsg0E4MRJnMcym1BK0xFlKK56+DUjICSlKIo0lAeik2zvn+sdeAk5OThsJJcyVqf12u9YJ+z9vt81rXXvs7KOnuvHSilFF5eXl5eXl5eXl4dpLjONuDl5eXl5eXl5eWW/ADUy8vLy8vLy8urQ+UHoF5eXl5eXl5eXh0qPwD18vLy8vLy8vLqUPkBqJeXl5eXl5eXV4fKD0C9vLy8vLy8vLw6VH4A6uXl5eXl5eXl1aHyA1AvLy8vLy8vL68OlR+Aenl5eXl5eXl5daj8ANTLyytm3XfffcyePfv69sGDBwmCgIMHD3aap8Zq7NGWCgoKCILAOleSfve73xEEAU899VRnW/Hy8upm8gNQL68uqp07dxIEwfVy++238/73v5/8/Hz+8Ic/dLa9Nmnfvn0UFBR0qocgCMjPz2/yvXCsjx071iyjqKiI//iP/2gHd+0r6fH38vLqfvIDUC+vLq41a9ZQUlJCcXExH//4x/nGN77B2LFjuXLlSod7+cQnPsHVq1f5xCc+0ab99u3bx+rVq9vJVfto+fLlXL16tcFrXXkA2tXi7+Xl1bUV39kGvLy8bk2f/vSnSUlJAeAf//EfGThwIBs3biQUCjFz5swm97l8+TJ9+vSx7iUuLo7bb7/dOlei4uPjiY/3KdTLy8srFvkZUC+vbqaHH34YgN/+9rcAzJ49m759+3Ly5EmmTJnCHXfcQVZWFgD19fV89atf5YMf/CC33347d911F7m5uVy4cKEBUynF2rVruffee+nduzd/8zd/w69+9aubPjvaNaA/+9nPmDJlCgMGDKBPnz58+MMfZvPmzdf9ff3rXwdocElBWLY92lLja0CDIODy5cv867/+6/U2hK89ffPNN/nSl77EfffdR0JCAoMGDWLixIn84he/aPFzKisr+fSnP02/fv3o27cvn/zkJ/npT3/aoE74EoHDhw+zYMEC7rzzTvr06UN6ejp//OMfm+W3FP+wvvnNbzJs2DASEhL46Ec/yssvv3xTnV//+tdkZGTw7ne/m9tvv52UlBS+973vtdjGphTuS+Xl5axevZqkpCTuuOMOMjIyqK2t5dq1a3zpS19i0KBB9O3bl89//vNcu3atAeNb3/oWDz/8MIMGDSIhIYH777+fb3zjGzd9Vn19PQUFBdxzzz3X+87//M//NHn98BtvvMGXvvQlBg8eTEJCAsOHD2f9+vXU19fH1E4vL1fl/3z38upmOnnyJAADBw68/lpdXR2TJ0/mwQcf5KmnnqJ3794A5ObmsnPnTj7/+c8zd+5cfvvb31JcXExlZSWHDx+mZ8+eAKxcuZK1a9cyZcoUpkyZwi9+8QsmTZrEX/7ylxb9HDhwgGnTppGYmMi8efO4++67efXVV9m7dy/z5s0jNzeX119/nQMHDlBSUnLT/h3hMay33nqLP/3pTze9funSpRb3LSkp4R//8R9JTU3lkUceAWDYsGEAPProo+zevZv8/Hzuv/9+zp8/z49//GNeffVVPvKRj0Rl/upXv2L8+PH069ePxYsX07NnT7Zt28aECRM4dOgQH/vYxxrU/+IXv8iAAQNYtWoVv/vd7/jqV79Kfn4+3/nOd6J+RkvxB/j2t7/Nm2++SW5uLkEQsGHDBv7+7/+eU6dOXY//r371K8aNG0dSUhJLliyhT58+lJeX89nPfpY9e/aQnp7eYgyb0le+8hV69erFkiVLOHHiBF/72tfo2bMncXFxXLhwgYKCAn7605+yc+dO3vve97Jy5crr+37jG9/ggx/8IH/3d39HfHw8//mf/0leXh719fX88z//8/V6X/7yl9mwYQOf+cxnmDx5Mq+88gqTJ0/mrbfeauDlypUrPPTQQ5w5c4bc3FyGDBnCT37yE7785S9z9uxZvvrVr8bURi8vJ6W8vLy6pL71rW8pQP3gBz9Qf/zjH1VNTY3atWuXGjhwoOrVq5d67bXXlFJKfe5zn1OAWrJkSYP9X3rpJQWo0tLSBq9///vfb/D6uXPn1G233aamTp2q6uvrr9dbunSpAtTnPve566/96Ec/UoD60Y9+pJRSqq6uTr33ve9VycnJ6sKFCw0+J5L1z//8z6qpdNQeHqMJaLG8/PLL1+uvWrXqJs99+vRp8rP69++v/vmf/7lFD4312c9+Vt12223q5MmT1197/fXX1R133KE+8YlPXH8t3Bc+9alPNWj//PnzVY8ePdQbb7zR7OdEi/9vf/tbBaiBAweqP//5z9dfD4VCClD/+Z//ef21T37yk+pDH/qQeuutt66/Vl9frz7+8Y+r973vfS22FWgQo3BfGjVqlPrLX/5y/fWZM2eqIAjUpz/96Qb7jx07ViUnJzd47cqVKzd9zuTJk9XQoUOvb//+979X8fHx6rOf/WyDegUFBTf1nSeeeEL16dNH/e///m+DukuWLFE9evRQ1dXVLbbTy8tLy/8E7+XVxfWpT32KO++8k8GDBzNjxgz69u1LRUUFSUlJDer90z/9U4Pt7373u/Tv35+JEyfypz/96Xp54IEH6Nu3Lz/60Y8A+MEPfsBf/vIXvvjFLzb4afZLX/pSi94qKyv57W9/y5e+9CXe9a53NXivNUsYdYTHSKWlpXHgwIGbyqJFi9rEaax3vetd/OxnP+P1119v9T7vvPMO+/fv57Of/SxDhw69/npiYiL/8A//wI9//GMuXrzYYJ9HHnmkQfvHjx/PO++8w+nTp2/J///5P/+HAQMGNOACnDp1CoA///nPvPjii2RmZvLmm29eP07nz59n8uTJ/OY3v+HMmTMxffasWbOuz7ICfOxjH0MpRU5OToN6H/vYx6ipqaGuru76a7169br+/9raWv70pz/x0EMPcerUKWprawH44Q9/SF1dHXl5eQ14X/ziF2/y8t3vfpfx48czYMCABv3xU5/6FO+88w7/9V//FVMbvbxclP8J3suri+vrX/8673//+4mPj+euu+5ixIgRxMU1/NsyPj6ee++9t8Frv/nNb6itrWXQoEFNcs+dOwdwffDyvve9r8H7d955Z4NBSVMKXw4watSo1jeogz1G6t577+VTn/rUTa+/9tprrWY0pQ0bNvC5z32OwYMH88ADDzBlyhRmzZrVYGDZWH/84x+5cuUKI0aMuOm9kSNHUl9fT01NDR/84Aevvz5kyJAG9cJtb3y9bFvVEvfEiRMopVixYgUrVqxoknHu3Lmb/iiK5bP79+8PwODBg296vb6+ntra2uuXnxw+fJhVq1Zx5MiRm1aFqK2tpX///tf7zvDhwxu8/+53v/umvvOb3/yGX/7yl9x5551Neg33Ry8vr5blB6BeXl1cqamp1++Cj6aEhISbBqX19fUMGjSI0tLSJveJ9iXbkeoKHlujzMxMxo8fT0VFBfv37+fJJ59k/fr1/Pu//zuf/vSnrX1Ojx49mnxdKdWu3PANOI899hiTJ09usm7jAd6tfnZLnk6ePMknP/lJPvCBD7Bx40YGDx7Mbbfdxr59+9i0aVNMNw3V19czceJEFi9e3OT773//+9vM9PJyVX4A6uXlqIYNG8YPfvADxo0b1+CnysZKTk4G9OxP5IzdH//4xxZn1sI34Rw/frzJmcWwov0c3xEebaq5ywoSExPJy8sjLy+Pc+fO8ZGPfITCwsKoA9A777yT3r17U1VVddN7v/71r4mLi7tpFrA9fLdG4Zj37Nmz2ePckfrP//xPrl27xve+970Gs6jhyzbCCvedEydO8N73vvf66+fPn7+p7wwbNoxLly6JaaOXV1eWvwbUy8tRZWZm8s477/DEE0/c9F5dXR1vvPEGoK8x7dmzJ1/72tcazKS15o7fj3zkI7z3ve/lq1/96nVeWJGs8Jqkjet0hEeb6tOnz01teOedd65fbxjWoEGDuOeee25aNihSPXr0YNKkSYRCIX73u99df/0Pf/gD3/72t3nwwQfp16+fNd9wc/xbq0GDBjFhwgS2bdvG2bNnb3q/paWg2kPhGdLI/lBbW8u3vvWtBvU++clPEh8ff9PyTMXFxTcxMzMzOXLkCC+88MJN773xxhsNrj/18vJqXn4G1MvLUT300EPk5ubyla98hf/3//4fkyZNomfPnvzmN7/hu9/9Lps3byYjI4M777yTxx57jK985StMmzaNKVOmUFlZyf/9v/+X97znPc1+RlxcHN/4xjf4zGc+w1/91V/x+c9/nsTERH7961/zq1/96voX+QMPPADA3LlzmTx5Mj169GDGjBkd4tGmHnjgAX7wgx+wceNG7rnnHt773vcyYsQI7r33XjIyMhg9ejR9+/blBz/4AS+//DJPP/10s7y1a9dy4MABHnzwQfLy8oiPj2fbtm1cu3aNDRs2WPUNN8e/Lfr617/Ogw8+yIc+9CHmzJnD0KFD+cMf/sCRI0d47bXXeOWVV6z5bY0mTZrEbbfdxmc+8xlyc3O5dOkS27dvZ9CgQQ0GyXfddRfz5s3j6aef5u/+7u/427/9W1555ZXrfSdydnjRokV873vfY9q0acyePZsHHniAy5cv89///d/s3r2b3/3udx3a37y8urQ67f57Ly+vW1J46Z3IpYGa0uc+9znVp0+fqO9/85vfVA888IDq1auXuuOOO9SHPvQhtXjxYvX6669fr/POO++o1atXq8TERNWrVy81YcIEdfz4cZWcnNzsMkxh/fjHP1YTJ05Ud9xxh+rTp4/68Ic/rL72ta9df7+urk598YtfVHfeeacKguCmJYFseowmGi0DFKmmYt3UMky//vWv1Sc+8QnVq1ev60v4XLt2TS1atEiNHj36evtHjx6ttmzZ0qInpZT6xS9+oSZPnqz69u2revfurf7mb/5G/eQnP2nRn1LRj0djRYt/eBmmJ5988qZ9ALVq1aoGr508eVLNmjVL3X333apnz54qKSlJTZs2Te3evbvFdjaOf9j7d7/73Va1NXw8/vjHP15/7Xvf+5768Ic/rG6//XZ13333qfXr16sdO3YoQP32t79t0P4VK1aou+++W/Xq1Us9/PDD6tVXX1UDBw5Ujz76aIPPefPNN9WXv/xlNXz4cHXbbbep97znPerjH/+4euqppxosF+Xl5dW8AqVu8ep0Ly8vLy+vbqY33niDAQMGsHbtWpYtW9bZdry8up38NaBeXl5eXk7r6tWrN70Wvn54woQJHWvGy8sR+WtAvby8vLyc1ne+8x127tzJlClT6Nu3Lz/+8Y8pKytj0qRJjBs3rrPteXl1S/kBqJeXl5eX0/rwhz9MfHw8GzZs4OLFi9dvTFq7dm1nW/Py6rby14B6eXl5eXl5eXl1qDrtGtCvf/3r3Hfffdx+++187GMf4+jRo51lxcvLy8vLy8vLqwPVKQPQ73znOyxYsIBVq1bxi1/8gtGjRzN58mT/HF0vLy8vLy8vLwfUKT/Bf+xjH+OjH/3o9SdN1NfXM3jwYL74xS+yZMmSFvevr6/n9ddf54477rjlR8h5eXl5eXl5eXndupRSvPnmm9xzzz3ExTU/x9nhNyH95S9/4ec//zlf/vKXr78WFxfHpz71KY4cOdLkPteuXWvwyLozZ85w//33t7tXLy8vLy8vLy+vtqmmpoZ777232Tod/hP8n/70J9555x3uuuuuBq/fdddd/P73v29yn6985Sv079//egkPPmuA2ojyRhu9vNFo/9qnY+e5wJLsTSpLsjepLMnepLIke5PKkuxNKkuyN6ksyd5sshrrjjvuaLFOh/8E//rrr5OUlMRPfvITxo4de/31xYsXc+jQIX72s5/dtE/jGdCLFy8yePBgaoF+EfUUbRtR1wNB5AsJwI2PaRPPBZZkb1JZkr1JZUn2JpUl2ZtUlmRvUlmSvUllSfZmu52Rqq2tpV+/fs3W6fAZ0Pe85z306NGDP/zhDw1e/8Mf/sDdd9/d5D4JCQn069evQWkshQ5mW3RT/fLYeS6wbPNcYNnmucCyzXOBZZvnAss2zwWWbZ4LLNs8qaxY1OED0Ntuu40HHniAH/7wh9dfq6+v54c//GGDGdFYtCWG+s1N/7aF5wLLNs8Flm2eCyzbPBdYtnkusGzzXGDZ5rnAss2TyopJqhO0a9culZCQoHbu3Kn+53/+Rz3yyCPqXe96l/r973/fqv1ra2sVoGpB1ZtyHFQfHctWlz5mvzBDZcfOc4El2ZtUlmRvUlmSvUllSfYmlSXZm1SWZG9SWZK92W5nZKmtrW1xLNcpA1CllPra176mhgwZom677TaVmpqqfvrTn7Z63/AA9M+gqkEtv4VA9TH7V4Oqe+jWeC6wJHuTypLsTSpLsjepLMnepLIke5PKkuxNKkuyN9vtDBfRA9BbUXgAaruEQp7VXbxJZUn2JpUl2ZtUlmRvUlmSvUllSfYmlSXZm01WawagnfYoTi8vLy8vLy8vL0fVAROW1tVeM6DDh3tWd/EmlSXZm1SWZG9SWZK9SWVJ9iaVJdmbVJZkbzZZfga0jcrI8KzO5LnAss1zgWWb5wLLNs8Flm2eCyzbPBdYtnlSWa2RH4BG6BZXgXKOZZvnAss2zwWWbZ4LLNs8F1i2eS6wbPNcYNnmSWW1Rn4AGqHz5z2rM3kusGzzXGDZ5rnAss1zgWWb5wLLNs8Flm2eVFZr1OGP4rShixcv0r9//8624eXl5eXl5eXl1UgiH8UpWaGQZ3UmzwWWbZ4LLNs8F1i2eS6wbPNcYNnmucCyzZPKao38ANTLy8vLy8vLy6tD5QegEdq717M6k+cCyzbPBZZtngss2zwXWLZ5LrBs81xg2eZJZbVK7b5oZzsovA7oG+hnll4GlRLjWlUpZv96UPVjb43nAkuyN6ksyd6ksiR7k8qS7E0qS7I3qSzJ3qSyJHuz3c5w6faP4qwFpcKBiyFgKRH7KlAqFDvPBZZkb1JZkr1JZUn2JpUl2ZtUlmRvUlmSvUllSfZmu52RxZmF6APz76E27heuHzR6PRaeCyzbPBdYtnkusGzzXGDZ5rnAss1zgWWb5wLLNk8qKyZ1wISldTWeAY0csdOGUh+xvwKlRsXOc4El2ZtUlmRvUlmSvUllSfYmlSXZm1SWZG9SWZK92W5nZGnNDGg8XVllQG8gC4IiUMlQeByKi2HrVl1l+3bo2RNmz9bbOTnw+OMwYgRwAlgL7DS8C0A5kKv/AlB5sCYXRo+GmhpYtAh27dJVy8vh7FmYN8/sOx+YCaQC54BfA4X6rSAEqgpCi/X2kiUwdSqMHw8XL0J2NuzZA/Hx8MILwFFgheEWmP/3AK5BkAmqFEJ94dAh2L8fCs3nrFsHo0bBtGl6Oy0N2AEMBI4Au4FdwElgIwRDQGVACMjMhE2bICkJKivh2Wd1HAG2bIH+/SEry3jKBlYDQ4G+pt3bTcx2QJqJM8CcObBgAYwcCadOwapVUFJiOKVALZBntl8BMoAxEJwBNR9C5fqt3buhulqzABYu1I8NGzvWLJ6bg24IwF7gQ0Cyif8yUJMg9BBcuqTbUV4OCQlw4AAcPgwFBbruE0+YYzgZqAOmm/5xBngJgudBrdMftWGD7kdpaXrf9HTYtg0GDYKjR6GsTMcUgM1AIpAJDAM+CjwJwWBQr0DSNh1n0IzevXW/AN13ly+H4cOBKmC9Oa4Afwb2AHNM/B+FwnzdD06fhqVLobRUVy0r07HKzzf7zgVmASnAWfT5EO6zFaBOQugxvb14sW7nuHFw4YL2VFEBcXGwbx9QCSwz3JXofhsHXIVgBqhdEOoFL74IBw/CmjW6amEhjBkDU6ZAfb2O4c6dwADgsDmmG0zM/kn/G6TrDBc/XffRxEQ4dgyeew6eeUZzi4th4ECYOdN4ygKKTJ/obdq91cRsO6RHyREnTsDatcYTQAlwBcg12//PHNPRENSAWgShKDli/nztJzUVzp0zjArDCQFjgCEm/ktATYVQlBxx9CisMDmioEAfFyYC14yfUu2JHcB+CAp1zMY2kSN27NCxOnJEn2dPP208bTR+Mkz8HwA2QZAEqhIGN5MjsrNh9WoYOhR41bC2G+55094cE/85sC5KjigthdpayAvniHzgCyZWZ4DfcaPP7gZVDaEoOSIn58YyM3v3wvHjwBLDXQZM0p54Bf2dUg4qAfKbyBGpqTB5MtTVwfTpxm8/4CXgeWCdiVkuMAKCNB3/uGZyxObNui9nZhpPM4AngcFAL+DzwBYTs22QESVHVFXB+vX6uAI6f70NzDHbleicPQqC06CWQihKjpg7F2bNgpQU3Zfz89H5BnTfPQl8w/y72LRzHOxsIkdUVsIykyNWroQJE4CHgaumrbu0J7YDByFYo2OWGiVHDBigj0sopHMxAE+ZuKebf/8KKIYgEdQxSG4mR2RlQVERJCcDx/V+mHEEfzTHdbaJfw5siJIjSkrgyhXINTkiL8/0g9FADbCIG9/D5RCcBTVPnxKNc0Ruro4h6HZWVek4A7rvTtWeqASyIdgDKh7youSIiRPh2jXdx0pL0d/fh4D96PNomOknoyCYpuNPMzli40YYMuTGIzwzM3UMFy6kdeqACUvrarcZ0JDFvyS6IUuyN6ksyd6ksiR7k8qS7E0qS7I3qSzJ3qSyJHuz3c7I4sw1oGFdjaG+inzhUuw8F1i2eS6wbPNcYNnmucCyzXOBZZvnAss2zwWWbZ5UVkzqgAlL64qcAa2PKLdyZ1r4L4FYeS6wJHuTypLsTSpLsjepLMnepLIke5PKkuxNKkuyN9vtjCzdfhmmN0yQrK3NVX5rPBdYkr1JZUn2JpUl2ZtUlmRvUlmSvUllSfYmlSXZm+12hku3H4DaLqGQZ3UXb1JZkr1JZUn2JpUl2ZtUlmRvUlmSvUllSfZmk+XcNaC3qgMHPKszeS6wbPNcYNnmucCyzXOBZZvnAss2zwWWbZ5UVmvkB6AROnzYszqT5wLLNs8Flm2eCyzbPBdYtnkusGzzXGDZ5klltUod8Iu5dfmf4GWwJHuTypLsTSpLsjepLMnepLIke5PKkuxNKkuyN/8TvJeXl5eXl5eXV/dWB0xYWld7zYCmpHhWd/EmlSXZm1SWZG9SWZK9SWVJ9iaVJdmbVJZkbzZZfga0jUpN9azO5LnAss1zgWWb5wLLNs8Flm2eCyzbPBdYtnlSWa2RH4BGaPJkz+pMngss2zwXWLZ5LrBs81xg2ea5wLLNc4FlmyeV1Rr5AWiE6uo8qzN5LrBs81xg2ea5wLLNc4Flm+cCyzbPBZZtnlRWaxQopVTHfuSt6+LFi/Tv37+zbXh5eXl5eXl5eTVSbW0t/fr1a7ZOl54BfQOoBy4DKTEyUsz+9UB9ya3xXGDZ5t0PnG/EOm9e70xfkmPmAkuyN6ksyd6ksiR7k8qS7E0qS7I32+1sk9r9lvV2UPgu+FpQCvMMU9r+7NKUiH0VKBWKnecCyzbv/hZY9/uYOcmS7E0qS7I3qSzJ3qSyJHuTypLszXY7I0u3fxZ8eAAaDtjlNgbocmTgQanHYue5wLLNO98C67yPmZMsyd6ksiR7k8qS7E0qS7I3qSzJ3my3M7I4NwCtb2OAGgQelBoZO88FlmRvUlmSvUllSfYmlSXZm1SWZG9SWZK9SWVJ9ma7nZGlNQPQeLqyyoDeQBYERaCSofA4FBfD1q26yvbt0LMnzJ6tt3Ny4PHHYcQI4ASwFthpeIlAAZALAaDyYE0ujB4NNTWwaBHs2qWrlpfD2bMwb57Zdz4wE0gFzgF3oQ8DEIRAVUFosd5esgSmToXx4+HiRcjOhj17ID4eXngBOAqsMNwC4F+B3wLXIMgEVQqhvnDoEOzfD4WFuuq6dTBqFEybprfT0oAdwEDgCLAbeNHwN0IwBFQGhIDMTNi0CZKSoLISnn1WxxFgyxbo3x+ysoynbGA1MBQYCTwIbDcx2wFpJs4Ac+bAggUwciScOgWrVkFJieGUArVAntnuBfwEGAPBGVDzIVSu39q9G6qrNQtg4ULIyICxY+H8eSAH3RCAvcbjBRP/ZaAmQeghuHRJt6O8HBIS4MAB/fzbggJd94knzDGcDNQB04H9wC+AlyB4HtQ6/VEbNuh+lJam901Ph23bYNAgOHoUysp0TAHYjO5fmYY/FHgSgsGgXoGkbTrOoBm9e+t+AbrvLl8Ow4cDVcB6c1wxzDXAHBP/R6EwX/eD06dh6VIoLdVVy8p0rPLzzb5zgVnoi33OAvdwo89WgDoJocf09uLFup3jxsGFC9pTRQXExcG+fUAlsMxwVwL/BpwCrkIwA9QuCPWCF1+EgwdhzRpdtbAQxoyBKVOgvl7HcOdOYABw2BzTDSZmmcAwCNK1zfjpuo8mJsKxY/Dcc/DMM5pbXAwDB8LMmcZTFlAEJAMfACYAW03MtkN6lBxx4gSsXWs8AZQAV4Bcs3078DNgNAQ1oBZBKEqOmD9f+0lNhXPnDKPCcELA54E/m/gvATUVQlFyxNGjsMLkiIICfVyYCFwzcSoFHgaeBPZDUKhjNraJHLFjh47VkSP6PHv6aeNpIzAEyDDxvw/YBEESqEoY3EyOyM6G1ath6FDgVcPabrh3m2ORY+I/B9ZFyRGlpVBbC3nhHJEPfAEYA5wBBqMvWgOC3aCqIRQlR+TkQMjkiL174fhxYInhLgMmAYvQOTILgnJQCZDfRI5ITdVL1tTVwfTpxm8/4CXgeWCdiVkGMAKCNB3/uGZyxObNui9nZhpPM8zxG4zusw8DW0zMtkFGlBxRVQXr1+vjCujvt7eBOWb7duAYMAqC06CWQihKjpg7F2bNgpQU3Zfz84E9hlMBnATK0d8pi007x8HOJnJEZSUsMzli5UqYMMG06app6y7gIRO7gxCs0TFLjZIjBgzQxyUU0rkYgKeAYUC6if9goBiCRFDHILmZHJGVBUVFkJwMHNf7YcYR3IXOu7NN/HNgQ5QcUVICV65ArskReXnoc300UBPRx47q2AVnQc3TKaBxjsjN1TEE3c6qKh1nQPfdqcBC4AdANgR7QMVDXpQcMXEiXLum+1hpKdAXOIT+jis0Mft70zemma+DZnLExo0wZIg+z0Bzi4r0udcqdcCEpXW12wxoyOJfEt2QJdmbVJZkb1JZkr1JZUn2JpUl2ZtUlmRvUlmSvdluZ2Rx7if4W74uY1zsPBdYtnk3XQPaiHVL14B205i5wJLsTSpLsjepLMnepLIke5PKkuzNdjsjixOP4gy3FvTsfVsUrn+dMSJ2ngss27zxLbDGN7VTB/iSHDMXWJK9SWVJ9iaVJdmbVJZkb1JZkr3Zbmeb1QETltYVngF9gxuj9FiXC0jhxl8B9aFb47nAss27nxszoWHWedq2BJNrMXOBJdmbVJZkb1JZkr1JZUn2JpUl2ZvtdoZLt/8J3nYJhTyrK3nrA2o5qGpQdebf5eZ1H7Puw5LsTSpLsjepLMnepLIke5PKkuzNJqs1A1D/KM4IxcXpu+w8q3N4bWH1AQ6ib4btEfH6O+gbsh+Ogzd9zLoFyzbPBZZtngss2zwXWLZ5LrBs86Syuv2jOG1r2zbP6kxeW1jzuXnwidkeA7zoY9ZtWLZ5LrBs81xg2ea5wLLNc4FlmyeV1Rr5AWiEBg3yrM7ktYX1CDcPPsOKAz7oY9ZtWLZ5LrBs81xg2ea5wLLNc4FlmyeV1Rr5AWiEjh71rM7ktYV1TzPvBUCCj1m3YdnmucCyzXOBZZvnAss2zwWWbZ5UVqvU7ncMtYPa6yakoUM9q6t4qyZi7bJGpR7UGR+zbsOS7E0qS7I3qSzJ3qSyJHuTypLszSbL3wXfxiL1bjKprM70thx957tqotSBetXHrNuwJHuTypLsTSpLsjepLMnepLIke+vou+D9T/BeXVKb0He7v4Pu7Zh/w3fBn+wkX15eXl5eXl6tUAdMWFpXe82APvywZ3Ulb82tA+pj1n1Ykr1JZUn2JpUl2ZtUlmRvUlmSvdlktWYGNB6v60pM9KzO5LWVdRlYa8qtsppTd4pZV2TZ5rnAss1zgWWb5wLLNs8Flm2eVFar1AETltbV+FGcb4N6Gj3zRRuL1EdaSWVJ9iaVJdmbTdZ9oE42Yvlz0/czySzJ3qSyJHuTypLszT+Ks40KD0BraXjn8y9p2xddSjjoYU7oBqu+jQfABZZkb1JZkr3ZZN2HvgyiMSvM8+em72fSWJK9SWVJ9iaVJdmb7XZGFqcGoOGgLW9DgMKj/uuMXg1Zlz2ry3iTypLszSbrRDOsMM+fm76fSWJJ9iaVJdmbVJZkb7bbGVmcvAv+kTbU7YVetPy6nrz5fc9qP54LLNs8qayhLbDAn5vtybLNc4Flm+cCyzbPBZZtnlRWLOraNyGVAb2BLKAIgmRIOg6JxbB1q66yfTv07AmzZ+vtnBx4/HEYMQI4gb6DZafhJQJTgFx9UFQerMmF0aOhpgYWLYJdu3TV8nI4exbmzTP7zgdmAqnAOWAQENJvBSFQVRBarLeXLIGpU2H8eLh4EbKzYc8eiI+HF14AjgIrDLcA+IRhXYMgE1QphPrCoUOwfz8UFuqq69bBqFEwbZreTksDdgADgSPAbmA6MBjYCMEQUBkanZkJmzZBUhJUVsKzz0JxseZs2QL9+0NWlvGUDaxGjzpGmrZuNzHbAWkmzgBz5sCCBTByJJw6BatWQUmJ4ZQCtUCe2e5l2jsGgjOg5kOoXL+1ezdUV2sWwMKFkJEBY8fC+fNAzo14sxf4cET8l4GaBKGH4NIl3Y7yckhIgAMH4PBhKCjQdZ94whzDyUCdiVeaidlLEDwPap1Gb9ig+1Famt43PV0/S3fQIP1EibIyHVMANqP7V6bhLwKehGAwqFcgaZuOM2hG7966X4Duu8uXw/DhQBWw3hxXDHMaMMfE/1EozNf94PRpWLoUSkt11bIyHav8fLPvXGAWkAKcRT9eKhyzClAnIfSY3l68WLdz3Di4cEF7qqiAuDjYtw+99tUyw10JPGRYV4EZEOyCe3vBvBfh4EFYs0ZXLSyEMWNgyhSor9cx3LkTGAAcNowNJmbfAYZBkK7/xI6frvtoYiIcOwbPPQfPPKO5xcUwcCDMnGk8mRxBMvABE7etJmbbIT1KjjhxAtauNZ4ASoArQK7Zvh1YA4yGoAbUIghFyRHz52s/qalw7pxhVBhOSDOux38JqKkQipIjjh6FFSZHFBTo48JE4Bq6j5UCDwOngP0QFOqYjW0iR+zYoWN15Ig+z55+2njaCAwBMkz8FwKbIEgCVQmDm8kR2dmwejUMHQq8aljbDfduTJIw8Z8D66LkiNJSqK2FvHCOyAe+AIwBzqDPy3DMdoOqhlCUHJGTAyFTd+9eOH4cWGK4y4BJ6PN9AJAFQTmoBMhvIkekpsLkyVBXB9OnG7/9gJeA54F1JmZlwAgI0nT845rJEZs3676cmWk8zUAPCAaj+2wSsMXEbBtkRMkRVVWwfr0+roD+fnsbmGO2bwcKgVEQnAa1FEJRcsTcuTBrFqSk6L6cnw/sMZwK9Hp34e+Uxaad42BnEzmishKWmRyxciVMmIDuoyZHsAudN34DHIRgjY5ZapQcMWCAPi6hkM7FADwFDAPSTfy/BBRDkAjqGCQ3kyOysqCoCJKTgeN6P8w4grsMc7aJfw5siJIjSkrgyhXINTkiLw99ro8GatC5PxyzcgjOgpqnu3HjHJGbq2MIup1VVTrOgO67Uw2rP5ANwR5Q8ZAXJUdMnAjXruk+VloK9AUOAftNn0hF545REEzT8aeZHLFxIwwZos8z0NyiIn3utUod8Iu5dTX3E3x1xBRwc8v00HjqGZRa05BV34bpZhdYkr1JZUn21lGsMK/aEk9qO30/61osyd6ksiR7k8qS7M12OyOL09eA9gH1Mjc/LafOvN6HJq5/SGrIuqVrKbohS7I3qSzJ3myybroGNIIV5t3SNaBC2imVJdmbVJZkb1JZkr1JZUn2ZrudkcWZAWh4pB55p21Lj2pcTsM7wOpBqVDD7VjvJuuuLMnepLIke7PJuo8bd8GHWdHOza7cTqksyd6ksiR7k8qS7E0qS7I32+2MLN3+JqRwS99BP5pxLHpxctA3PPSIsl+cef8Y+pKHqxE8zHaqeb+1coEl2ZtUlmRvNlm/A4YDv41gRTs3O9qbCyzJ3qSyJHuTypLsTSpLsjfb7WyzOmDC0rpa8yjOaLOf4VLXxD5TpsQ+2neRJdmbVJZkb1JZkr1JZUn2JpUl2ZtUlmRvUlmSvdlkdfsZ0Ob0ejPvqSjv9+5t7/NdYNnmucCyzXOBZZvnAss2zwWWbZ4LLNs8F1i2eVJZrVG3HYB+E/3zX1OqN+83VnhJCxtygWWb5wLLNs8Flm2eCyzbPBdYtnkusGzzXGDZ5klltUbddgC6Cb004TvoGU/Mv++Y1zd1ki8vLy8vLy8vL+fVAZdsWldrrgGFltcBbVwGDLB3/YMLLMnepLIke5PKkuxNKkuyN6ksyd6ksiR7k8qS7M0my+lrQEHfdbsW/TCPePPvWqLfjbt8ub3PdoFlm+cCyzavO7D6AMuBavTDp6rNdh8B3roqyzbPBZZtngss2zwXWLZ5UlmtUdd+FKdlDR/uWZ3Jc4Flm9fVWX2Ag+gnK4aXTRuMfiJrGjAB/QdjV29nR7Ns81xg2ea5wLLNc4FlmyeV1Rp16xnQtqqqyrM6k+cCyzavq7Pm03DwGVYP8/r8NvJaIxdYtnkusGzzXGDZ5rnAss2TymqVOuCSTetq7TWgbS0DB3pWd/EmlSXZW2ewqom+Vm89N54f39Xb2dEsyd6ksiR7k8qS7E0qS7I3m6xu/yhO2yUU8qzu4k0qS7K3zmC19oERXb2dHc2S7E0qS7I3qSzJ3qSyJHuzyer2NyG9gV7T8zxwf4yM+83+9cBnbpHnAkuyN6ksyd46m3W2mfeU+bc7tLMjWJK9SWVJ9iaVJdmbVJZkb7bb2SZ1wISldYVnQGu58VNdPaj72zhCvz9iXwVKpcfOc4El2ZtUlmRvElgFPXpEnQXtbG9diSXZm1SWZG9SWZK9SWVJ9ma7nZGl28+AhhWYf19q437h+uH9eTt2ngssyd6ksiR7k8DaHBfHr3r2vOmBEfUCvHUllmRvUlmSvUllSfYmlSXZm+12tlkdMGFpXY1nQCNH7LSh1Efsr0CpUOw8F1iSvUllSfYmgRUEgRrQs6cqiI9XrwWBqgNVI8RbV2JJ9iaVJdmbVJZkb1JZkr3Zbmdkac0MaNdeB7QM6A1kQVAEKhkKj0NxMWzdqqts3w49e8Ls2Xo7JwcefxxGjABOoFem32l4icAUIFf/BaDyYE0ujB4NNTWwaBHs2qWrlpfD2bMwb57Zdz4wE0gFzpnXQvqfIASqCkKL9faSJTB1KowfDxcv6uev7tkD8fHwwgvAUWCFYRQA7zWsaxBkgiqFUF84dAj274fCQl113ToYNQqmTdPbaWnADmAgcATYbfyFgI0QDAGVoTczM2HTJkhKgspKePZZHUeALVugf3/IyjKesoHVwFBgJDAI2G5itkOv35iTo6vOmQMLFsDIkXDqFKxaBSUlhlMK1AJ5ZruXae8YCM6Amg+hcv3W7t1QXa1ZAAsXQkYGjB0L588DOTfizV5gQET8l4GaBKGH4NIl3Y7yckhIgAMH4PBhKCjQdZ94wsRoMnpV9OnARwzrJQieB7VOb27YoPtRWpreNz0dtm2DQYPg6FEoK9MxBWAzun9lGn4v4EkIBoN6BZK26TiDZvTufeO5vLNn6wWChw8HqoD15rhimNOAOSb+j0Jhvu4Hp0/D0qVQWqqrlpXpWOXnm33nArOAFPTFmEFEzCpAnYTQY3p78WLdznHj4MIF7amiAuLiYN8+9PNtlxnuStM3QsBVCGaA2gWhXvDii3DwIKxZo6sWFirGjHmbMVPg5Xodw507YdYA4LBhbDAxGw8MgyBdZ7j46bqPJibCsWPw3HPwzDOaW1wMAwfCzJnGUxZQBCQDHzBx22pith3So+SIEydg7VrtCYAS4AqQa7ZvB9YAoyGoAbUIQlFyxPz52k9qKpw7ZxgVhhMC3h0R/yWgpkIoSo44ehRWmBxRUKCPCxOBa+g+VmpitgDYD0GhjtnYJnLEjh06VkeO6PPs6aeNp43op3dkGFYCsAmCJFCVMLiZHJGdDatXw9ChwKuGtd1w78YkCRP/ObAuSo4oLYXaWsgL54h84AvoNbrOoBcSDMdsN6hqCEXJETk5EDJ19+6F48eBJYa7DJhk2lmK/k4pB5UA+U3kiNRUmDwZ6upg+nTjtx96yuh5YJ1hjQNGQJCm4x/XTI7YvFn35cxM42kG8CR6YdwPAEnAFhOzbZARJUdUVcH69fq4Avr77W1gjtm+HSgERkFwGtRSCEXJEXPnwqxZkJKi+3J+PrDHcCqAk9z4Tlls2jkOdjaRIyorYZnJEStXwoQJwMPAVdPWXYY1DzgIwRods9RCGDMGpkyB+ogcMWCAPi6hkM7FADwFDAPSDSseKIYgEdQxSG4mR2RlQVERJCcDx/V+mHEEdxnmbBP/HNgQJUeUlMCVK5BrckReHvpcHw3UAIsiYlYOwVlQ8/Rm4xyRm6tjCLqdVVU6zoDuu1MNqwTIhmAPqHjIi5IjJk6Ea9d0HystBfoCh4D9pk+kAmNN35im408zOWLjRhgyRJ9noLlFRfrca40CpZRqXVU5unjxIv3796cWfc6HpWjbwqb1REw9g/5Sirgroi08F1iSvUllSfYmlSXZm1SWZG9SWZK9SWVJ9iaVJdmb7XZGqra2ln79+jVbp1tcAwo6UPVt3Oem+vk3/ttWngss2zwXWLZ5LrBs81xg2ea5wLLNc4Flm+cCyzZPKisWdZsBKMCWGOo3mP4dFTvPBZZtngss2zwXWLZ5LrBs81xg2ea5wLLNc4FlmyeVFZPa/Y6hdlDkTUjhC2WPg+pD2y6S7WP2CzPUM7HzXGBJ9iaVJdmbVJZkb1JZkr1JZUn2JpUl2ZtUlmRvttsZWbr9k5D+jH5U3/JbCFQfs381qLq+t8ZzgSXZm1SWZG9SWZK9SWVJ9iaVJdmbVJZkb1JZkr3Zbme4dPsBqO0i9ZFWUlmSvUllSfYmlSXZm1SWZG9SWZK9SWVJ9iaVJdmbfxSnl5eXl5eXl5dXt5YfgEaorMyzOpPnAss2zwWWbZ4LLNs8F1i2eS6wbPNcYNnmSWW1Rn4AGqHz5z2rM3kusGzzXGDZ5rnAss1zgWWb5wLLNs8Flm2eVFar1AGXbFqXvwZUBkuyN6ksyd6ksiR7k8qS7E0qS7I3qSzJ3qSyJHvz14B6eXl5eXl5eXl1b3XAhKV1tdcMaHKyZ3UXb1JZkr1JZUn2JpUl2ZtUlmRvUlmSvUllSfZmk+VnQNuoWbM8qzN5LrBs81xg2ea5wLLNc4Flm+cCyzbPBZZtnlRWa+QHoBFKSfGszuS5wLLNc4Flm+cCyzbPBZZtngss2zwXWLZ5UlmtkR+ARujsWc/qTJ4LLNs8F1i2eS6wbPNcYNnmucCyzXOBZZsnldUqdcAlm9YVvgb0DfQzSy+DSonxOoUUs389qPr4W+O5wJLsTSpLsjepLMnepLIke5PKkuxNKkuyN6ksyd5stzNcuv2jOGtBqXDgYghYSsS+CpQKxc5zgSXZm1SWZG9SWZK9SWVJ9iaVJdmbVJZkb1JZkr3ZbmdkceYmpMD8e6iN+4XrB41ej4XnAss2zwWWbZ4LLNs8F1i2eS6wbPNcYNnmucCyzZPKikXdYgAaVq8Y6jcIfEXsPBdYtnkusGzzXGDZ5rnAss1zgWWb5wLLNs8Flm2eVFYsim9nfvuqDOgNZEFQBCoZCo9DcTFs3aqrbN8OPXvC7Nl6OycHHn8cRowATgBrgZ2GdwyYAuTqg6LyYE0ujB4NNTWwaBHs2qWrlpfrC3bnzTP7zgdmAqnAOeDfgJB+KwiBqoLQYr29ZAlMnQrjx8PFi5CdDXv2QHw8vPACcBRYYbgFwGjDugZBJqhSCPWFQ4dg/34oLNRV162DUaNg2jS9nZYG7AAGAkeA3cA/AunARgiGgMrQ6MxM2LQJkpKgshKefVbHEWDLFujfH7KyjKdsYDUwFHgT2AdsNzHbAWkmzgBz5sCCBTByJJw6BatWQUmJ4ZQCtUCe2X7OtHcMBGdAzYdQuX5r926ortYsgIULISMDxo41jw/LuRFv9qJ7djj+y0BNgtBDcOmSbkd5OSQkwIEDcPgwFBTouk88YY7hZKAOmG6OazrwEgTPg1qn0Rs26H6Ulqb3TU+Hbdtg0CA4elQ/V3fTJuNpM5AIZALvBr4DPAnBYFCvQNI2HWfQjN69db8A3XeXL4fhw4EqYL05rpi+Mg2YY+L/KBTm635w+jQsXQqlpbpqWZmOVX6+2XcuMAtIAc4CuyJiVgHqJIQe09uLF+t2jhsHFy5oTxUVEBcH+/YBlcAyw12pjyHpwFUIZoDaBaFe8OKLcPAgrFmjqxYWwpgxMGUK1NfrGO7cCQwADhs/G0zMTgLDIEjXv/HET9d9NDERjh2D556DZ57R3OJiGDgQZs40nrKAIiAZ3edeALaamG2H9Cg54sQJWLvWeAIoAa4AuWb7X4E1wGgIakAtglCUHDF/vvaTmgrnzhlGOOGHgNsj4r8E1FQIRckRR4/CCpMjCgr0cWEicA3dx0qBISZu+yEo1DEb20SO2LFDx+rIEX2ePf208bTRMDIMpwzYBEESqEoY3EyOyM6G1ath6FDgVcPabrg/xSQJE/85sC5KjigthdpayAvniHzgC+j+dQbYExGz3aCqIRQlR+TkQMjU3bsXjh8HlhjuMmASus9ORH+nlINKgPwmckRqKkyeDHV1MH268dsPeAl4HlhnYvYbYAQEaTr+cc3kiM2bdV/OzDSeZgBPAoOBC8ABYIuJ2TbIiJIjqqpg/Xp9XAH9/fY2MMdsfwsoBEZBcBrUUghFyRFz5+qleVJSdF/OzzcxB913T5rjkQ4sNu0cBzubyBGVlbDM5IiVK2HCBOBh4Kpp6y4gCegPHIRgjY5ZapQcMWCAPi6hkM7FADwFDDN+3o3+Hi6GIBHUMUhuJkdkZUFRESQnA8f1fphxBD8xzNkm/jmwIUqOKCmBK1cg1+SIvDz0uT4aqAEWRcSsHIKzoObpbtw4R+Tm6hiCbmdVlY4zoPvuVPS59EkgG4I9oOIhL0qOmDgRrl3Tfay0FOiLnubcb/rEu9HfMaMgmKbjTzM5YuNGGDJEn2eguUVF+txrlTrgkk3ranwNaOQ1C7Sh1EfsH3n9Qyw8F1iSvUllSfYmlSXZm1SWZG9SWZK9SWVJ9iaVJdmb7XZGFmeuAQ3ragz1lSWeCyzbPBdYtnkusGzzXGDZ5rnAss1zgWWb5wLLNk8qKyZ1wISldUXOgNZHlFu5M60elBoRO88FlmRvUlmSvUllSfYmlSXZm1SWZG9SWZK9SWVJ9ma7nZGl2y/D9IYJkrW1uRbfGs8FlmRvUlmSvUllSfYmlSXZm1SWZG9SWZK9SWVJ9ma7neHS7Qegtkso5FndxZtUlmRvUlmSvUllSfYmlSXZm1SWZG9SWZK92WQ5dw3orerCBc/qTJ4LLNs8F1i2eS6wbPNcYNnmucCyzXOBZZsnldUaBUop1bEfeeu6ePEi/fv372wbXl5eXl5eXl5ejVRbW0u/fv2areNnQCMUXm/LszqH5wLLNs8Flm2eCyzbPBdYtnkusGzzXGDZ5klltUZ+ABqhOIvRcIFlm+cCyzbPBZZtngss2zwXWLZ5LrBs81xg2eZJZbXq8zr242Rr3z7P6kyeCyzbPBdYtnkusGzzXGDZ5rnAss1zgWWbJ5XVGvkBaIQqKz2rM3kusGzzXGDZ5rnAss1zgWWb5wLLNs8Flm2eVFar1O5rJrWD/DJMMliSvUllSfYmlSXZm1SWZG9SWZK9SWVJ9iaVJdmbX4bJy8vLy8vLy8ure6sDJiytq71mQEeP9qzu4k0qS7I3qSzJ3qSyJHuTypLsTSpLsjepLMnebLK6/QzoG0A9cBlIiZGRYvavByon3BrPJut+4Hwj1nnzemf6ss1zgSXZm9Q+a9ubCyzJ3qSyJHuTypLsTSpLsjfb7WyTOmDC0rrCM6C1oBTmGaa0/dmlKRH7KlAqFDvPJuv+Flj3d5IvyTGTypLsTWqfldxOqSzJ3qSyJHuTypLsTSpLsjfb7Yws3X4GNKzA/HuojfuF64f352rsPJusl1pgvUTrZdOXbZ4LLMnepPZZ295cYEn2JpUl2ZtUlmRvUlmSvdluZ1vVpR/FWQv0M6+FG9GWEXU9EYFvpLbyXGDZ5rnAss1zgWWb5wLLNs8Flm2eCyzbPBdYtnlSWY3VmkdxxsfIjqqCggJWr17d4LURI0bw61//GoC33nqLhQsXsmvXLq5du8bkyZPZsmULd911V9s/rAzoDWRBUAQqGQqPQ3ExbN2qq2zfDj17wuzZejsnBx5/HEaMAE4Aa4GdhjcQKAJy9UFRebAmF0aPhpoaWLQIdu3SVcvL4exZmDfP7DsfmAmkAufQI+Pb9VtBCFQVhBbr7SVLYOpUGD8eLl6E7GzYswfi4+GFF4CjwIpwQIF/AV4DrkGQCaoUQn3h0CHYvx8KC3XVdetg1CiYNk1vp6UBO0y7jgC7gYPAz4GNEAwBlQEhIDMTNm2CpCS9Ftizz+o4AmzZAv37Q1aW8ZQNrAaGAu8DJgDbTcx2QJqJM8CcObBgAYwcCadOwapVUFJiOKVALZBntgPgF8AYCM6Amg+hcv3W7t1QXa1ZAAsXQkYGjB0L588DOeiGAOwFMoErBrsM1CQIPQSXLul2lJdDQgIcOACHD0NBga77xBPmGE4G6oDpwG+BXwIvQfA8qHX6ozZs0P0oLU3vm54O27bBoEFw9CiUlemYArAZSDS+HjBxexKCwaBegaRtOs6gGb17634Buu8uXw7DhwNVwHpzXDHHdh0wx8T/USjM1/3g9GlYuhRKS3XVsjIdq/x8s+9cYBb6Yp+zwABu9NkKUCch9JjeXrxYt3PcOLhwQXuqqNBPzti3D6gElhnuSuBbQA1wFYIZoHZBqBe8+CIcPAhr1uiqhYUwZgxMmQL19TqGO3caL4fNMd1gYjYTGAZBuk6O8dN1H01MhGPH4Lnn4JlnNLe4GAYOhJkzjacs9LmdDAwHPgVsNTHbDulRcsSJE7B2rfEEUGL6VS439AowGoIaUIsgFCVHzJ+v/aSmwrlzhlFhGCHgH9AXXwHBElBTIRQlRxw9CitMjigo0MeFicA1dB8rBR4CNgL7ISjUMRvbRI7YsUPH6sgRfZ49/bTxtBEYAmSY+A8DNkGQBKoSBjeTI7KzYfVqGDoUeNWwthvuu4GngBwT/zmwLkqOKC2F2lrIC+eIfOALwBjgDPAeIMHEbDeoaghFyRE5ORAyOWLvXjh+HFhiuMuAScAC9LRPFgTloBIgv4kckZoKkydDXR1Mn2789kNP9T+PPicfAP4PMAKCNB3/uGZyxObNui9nZhpPM4AngcEm9pOBLSZm2yAjSo6oqoL16/VxBfT329vAHG7oODAKgtOglkIoSo6YOxdmzYKUFN2X8/OBPYZRAZxEfw//HFhs2jkOdjaRIyorYZnJEStXwoQJwMPoWbcZwC7gQdPmgxCs0TFLjZIjBgzQxyUU0rkYTL8aBqSb+N8HFEOQCOoYJDeTI7KyoKgIkpNNfIoBM45gALAJmG3inwMbouSIkhK4cgVyTY7Iy0Of66PROXER8BsTs3IIzoKap1NA4xyRm3vj8ZihkD62mHEES4CpwJeAHwHZEOwBFQ95UXLExIlw7ZruY6WlQF90f98PFJqY/f9M35hmBqHN5IiNG2HIEH2egeYWFelzr1WyfX3mqlWr1Ac/+EF19uzZ6+WPf/zj9fcfffRRNXjwYPXDH/5QHTt2TP31X/+1+vjHP96mz2h8DWjkNQu0odRH7B95/UMsPBdYkr1JZUn2JpUl2ZtUlmRvUlmSvUllSfYmlSXZm+12RpbWXANqfQYUID4+nrvvvvum12tra3n22Wf59re/zcMPPwzAt771LUaOHMlPf/pT/vqv//qWPvdqDPV7ETEF/WLsPJusC+g/uKKxLnSSL9s8F1iSvUnts7a9ucCS7E0qS7I3qSzJ3qSyJHuz3c62ql1uQvrNb37DPffcw9ChQ8nKyqK6uhqAn//857z99tt86lOful73Ax/4AEOGDOHIkSMxfVZ4uA36F6e2KFz/OuNg7DybrPEtsMY3sU9H+LLNc4El2ZvUPmvbmwssyd6ksiR7k8qS7E0qS7I32+1ss9r8G3sL2rdvnyovL1evvPKK+v73v6/Gjh2rhgwZoi5evKhKS0vVbbfddtM+H/3oR9XixYujMt966y1VW1t7vdTU1ChAvYGeIr5M7MsFpJj960HVh26NZ5N1P6jzjVjnaftyNrZ9SY6ZVJZkb1L7rOR2SmVJ9iaVJdmbVJZkb1JZkr3Zbme4tOYneOsD0Ma6cOGC6tevn/qXf/mXmAegq1atuqVAtLZIfaaqVJZkb1JZkr1JZUn2JpUl2ZtUlmRvUlmSvUllSfbW0c+Cb/cBqFJKpaSkqCVLlqgf/vCHClAXLlxo8P6QIUPUxo0bo+4fbQbUdklN9azu4k0qS7I3qSzJ3qSyJHuTypLsTSpLsjepLMnebLJELER/6dIlTp48SWJiIg888AA9e/bkhz/84fX3q6qqqK6uZuzYsVEZCQkJ9OvXr0FpD40Z41mdyXOBZZvnAss2zwWWbZ4LLNs8F1i2eS6wbPOksloj6wPQxx57jEOHDvG73/2On/zkJ6Snp9OjRw9mzpxJ//79+cIXvsCCBQv40Y9+xM9//nM+//nPM3bs2Fu+A96GpkzxrM7kucCyzXOBZZvnAss2zwWWbZ4LLNs8F1i2eVJZrZH1ZZhee+01Zs6cyfnz57nzzjt58MEH+elPf8qdd94JwKZNm4iLi2P69OkNFqKXoPp6z+pMngss2zwXWLZ5LrBs81xg2ea5wLLNc4FlmyeV1Rp16Udxenl5yVIf9EPBHgHuAV4Hvol+iMjlTvTl5eXl5dVxas2jONv9GtCupOuP2+uirD7AcqAa/RTJarPdp5182ea5wLLNk8Tqg37SawEweCf0QD9FsMC83qfp3VolSe3sCizbPBdYtnkusGzzXGDZ5klltUZ+ABqhAQO6LqsP+pGuBegv/Whf/jZ92ea5wLLNk8Saj35Edw/Qj0Uy6mFen38LbEnt7Aos2zwXWLZ5LrBs81xg2eZJZbVGfgAaocOHuy5rPvBXmC//CDX+8rfpyzbPBZZtniTWI0T0v0asOPN+rJLUzq7Ass1zgWWb5wLLNs8Flm2eVFardGsrfHaOamtrra7JFS4jRnRdVjUoFaXUm/dt++rqMesMlmRvt8qqI6Lfjbi5H9Z1k3Z2BZZkb1JZkr1JZUn2JpUl2ZtNlpiF6G0rPAB9A/94rHBp8OXfRHnHkq/ObmdXZPUB9TSotxvxToK6rxu18ywRfS4U/Y+grt5OqSzJ3qSyJHuTypLsTSpLsrdu/SjO9lB4AFrLjS+3+hgClhKxr+LGl2YsvM5mtTQDasOXhHZ2NVYfUL+MZDXi1dG2QajUdkZjhUsdqOXCvHUnlmRvUlmSvUllSfYmlSXZm+12RhZnBqDhgF1uY4DCo/4wQ42PndfZrOVEnwW15UtCO7saa3ljVhO8E92gnS2x6tCDcYneugNLsjepLMnepLIke5PKkuzNdjsji4hHcXakesVQP4h8YVjsvM5mbQIqgXfQRx9u9ARbvmL15jLrkcasJnhD28CT2s6WWHG0bR3QrtrOzmLZ5rnAss1zgWWb5wLLNk8qKxZZfxJSh6oM6A1kQVAEKhkKj0NxMWzdqqts3w49e8Ls2Xo7JwcefxxGjABOAGuBnYaXCJwDcvVBUXmwJhdGj4aaGli0CHbt0lXLy+HsWZg3z+w7H5gJpBrGICBdvxWEQFVBaLHeXrIEpk6F8ePh4kXIzoY9eyA+Hl54ATgKrDDcAmCBYV2DIBNUKYT6wqFDsH8/FBbqqo+vg7mjYNI0uB14LQ3u3QEMBI4Au4GvGNZGCIaAyoAQkJkJmzZBUhJUVsKzz+o4AmzZAv37Q1aW8ZQNrEaPnEYC+4DtJmY7IM3EGWDOHFiwAEaOhFOnYNUqKCkxnFKgFsgz272A+4AxEJwBNR9C5fqt3buhulqzABYuhIwMGDsWzp8HctANAdhrPIbjvwzUJAg9BJcu6XaUl0NCAhw4oO/8KyjQdZ94whzDyejFVKcDTxjWSxA8D2qd/qgNG3Q/SkvT+6anw7ZtMGgQHD0KZWVw7ybjabPpX5mG/x3gSQgGg3oFkrbpOINm9O6t+wXovrt8OQwfDlQB64EdhpsI/AmYY+L/KBTmw6hRcPo0LF0KpaW6almZjlV+vtl3LjALSAHOoleOD8esAtRJCD2mtxcv1u0cNw4uXNCeKiogLg727UP/9bPMcFcCCw3rKgQzQO2CUC948UU4eBDWrNFVCwv184enTNFP4UhPN2vRDUDfSR8CNpiYnQSGQZCu/7CKn677aGIiHDsGzz0HzzyjucXFMHAgzJxpPGUBRUAy8AHgBWCridl2SI+SI06cgLVrI9bHKwGuALlm+3b0eTAaghpQiyAUJUfMn6/9pKbCOZNnqDCcEPD5iPgvATUVQlFyxNGjsMLkiIICfVyYCFxD97FS4GHg3cB+CAp1zMau031j2jS9b1oa7NihY3XkiD7Pnn7aeNoIDAEyTPzLgE0QJIGqhMHN5IjsbFi9GoYOBV41rO2GezdwAcgx8Z8D66LkiNJSqK2FvHCOyAe+gF7a4wx6rblwzHaDqoZQlByRkwMhkyP27oXjx4ElhrsMmAQsMnHMgqAcVALkN5EjUlNh8mSoq4Pp043ffsBLwPPAOhOz3wAjIEjT8Y9rIkdsMjli82bdlzMzjacZwJOmjR8ADgBbTMy2QUaUHFFVBevX6+MK6O+3t4E5Zvt24H3AKAhOg1oKoSg5Yu5cmDULUlJ0X87PB/YYTgX6nAx/pyw27RwHO5vIEZWVsMzkiJUrYcIEdB+9atq6C3gI6A8chGCNjllqlBwxYIA+LqGQzsUAPIUeRKWb+P8bUAxBIqhjkNxMjsjKgqIiSE4Gjuv9MOMI7kJ/V8028c+BDVFyREkJXLkCuSZH5OWhz/XRQI3pY+GYlUNwFtQ8nQIa54jcXB1D0O2sqtJxBnTfnYrOtZ8EsiHYAyoe8qLkiIkT4do13cdKS4G+6PUb9wOFJmZVpm9MM5NZzeSIjRthyBB9noHmFhXpc69V6oBfzK0r2k/w9W2cIr7pp9FQ7DwXWJK9SWU1eW2uEG9SWZK9SWVJ9iaVJdmbVJZkb1JZkr3Zbmdkac1P8F36UZy16D86Qbf4Km172splGk1Bx6NnvWLgucCS7E0qazmwJpLVBO8UMLwTvEllSfYmlSXZm1SWZG9SWZK9SWVJ9ma7nZFy4lGc4eE26Nn7tihc/zqjOHaeCyzJ3qSyNqF/zYncP5JXD3yqk7xJZUn2JpUl2ZtUlmRvUlmSvUllSfZmu51tVrv/Xt4O8uuAdh5LsjepLFfWAfX9zMesq7Eke5PKkuxNKkuyN9vtDJduvwyT7bJihWd1F29SWZK9SWVJ9iaVJdmbVJZkb1JZkr1JZUn2ZpPlB6BtLMnJntVdvEllSfYmlSXZm1SWZG9SWZK9SWVJ9iaVJdmbTZYfgLaxhEKe1V28SWVJ9iaVJdmbVJZkb1JZkr1JZUn2JpUl2ZtNlnML0Xt5eXl5eXl5eXUBdcCEpXW11wzoxIme1V28SWVJ9iaVJdmbVJZkb1JZkr1JZUn2JpUl2ZtNlp8BbaMGDvSszuR1d1Yf9LqgZQP1UmvVZjvWddZAZjtts2zzXGDZ5rnAss1zgWWb5wLLNk8qq1XqgAlL6/LXgMpgSfYmjdUH1Mug6mj4tIk683qfbtLO9mBJ9iaVJdmbVJZkb1JZkr1JZUn25q8B9fLqhpqPfnx1j0av9zCvz+9wR15eXl5eXp2oDpiwtK72mgHt29ezuos3aawGz4Tv2/D5u/Xm/e7QzvZgSfYmlSXZm1SWZG9SWZK9SWVJ9maT5WdA26iiIs/qTF53Zt3TANjwvaDx+22QtHa2B8s2zwWWbZ4LLNs8F1i2eS6wbPOkslqlDpiwtK7Gj+I8D+r+GEfp95v9Ix9DFSvPBZZt3n2gTjRinSC2R1TaZNmO2etEzHqGbm0GVGrfkNzPXGBJ9iaVJdmbVJZkb1JZkr3Zbme4dPuF6Gu58QVeH0PA7o/YV4FShbHzXGDZ5t2HvgmnKVYdbRs42mR1VMzCpQ7U8i7eNyT3MxdYkr1JZUn2JpUl2ZtUlmRvttsZWZwZgIYDdr6NAQqP+sMMlRg7zwWWbd7JFlgnLbLeBrWC1t1t3tEx+0srfUnuG5L7mQssyd6ksiR7k8qS7E0qS7I32+2MLM4NQOvbGKAGgYcGP422lecCS7K35ljhUgfqGC0P9nzMfD/raizJ3qSyJHuTypLsTSpLsjfb7YwsrRmAxtOVVQb0BrIgKAKVDIXHobgYtm7VVbZvh549YfZsvZ2TA48/DiNGACeAtcBOw0sEpgC5+sYQlQdrcmH0aKipgUWLYNcuXbW8HM6ehXnzzL7zgZlAKnDOvBbS/wQhUFUQWqy3lyyBqVNh/Hi4eBGys2HPHoiPhxdeAI4CKwyjAHivYV2DIBNUKYT6wqFDsH8/FBbqquvWwahRMG2a3k5LA3YAA4EjwG7jLwRshGAIqAy9mZkJmzZBUhJUVsKzz+o4AmzZAv37Q1aW8ZQNrAaGAiOBQcB2E7MdkGbiDDBnDixYACNHwqlTsGoVlJQYTilQC+SZ7V6mvWMgOANqPoTK9Vu7d0N1tWYBLFwIGRkwdiycPw/k3Ig3e4EBEdvLgEnQ4yEYcwnmZ8GHyyEhAQ4cgMOHoaBAV33iCROjyejV4qcDHzGslyB4HtQ6vblhg+5HaWl63/R02LYNBg2Co0ehrEzHFIDN6P6Vafi9gCchGAzqFUjapuMMmtG7t+4XoPvu8uUwfDhQBaw3xxXDnAbMMfF/FArzdT84fRqWLoXSUl21rEzHKj/f7DsXmAWkAGfRgHCfrQB1EkKP6e3Fi3U7x42DCxe0p4oKiIuDffuAShNngJWmb4SAqxDMALULQr3gxRfh4EFYs0ZXLSyEMWNgyhSor9cx3LnTHL/DhrHBxGw8MAyCdJ3h4qfrPpqYCMeOwXPPwTPPaG5xsV5UeeZM4ykLffNXMvABE7etJmbbIT1KjjhxAtauNZ4ASoArQK7Zvh1YA4yGoAbUIghFyRHz52s/qalw7pxhVBhOCHh3RPyXgJoKoSg54uhRWGFyREGBPi5MBK6h+1ipidkCYD8EhTpmY5vIETt26FgdOaLPs6efNp42AkOADMNKADZBkASqEgY3kyOys2H1ahg6FHjVsLYb7t2YJGHiPwfWRckRpaVQWwt54RyRD3wBvXbZGSAuIma7QVVDKEqOyMmBkKm7dy8cPw4sMVyTI0g1scuCoBxUAuQ3kSNSU2HyZKirg+nTjd9+wEvA88A6wxoHjIAgTcc/rpkcsXmz7suZmcbTDOBJYDC6zyYBW0zMtkFGlBxRVQXr1+vjCujvt7eBOWb7dqAQGAXBaVBLIRQlR8ydC7NmQUqK7sv5+cAew6kATnLjO2Wxaec42NlEjqishGUmR6xcCRMmAA8DV01bdxnWPOAgBGt0zFKj5IgBA/RxCYV0LgbgKWAYkG5Y8UAxBImgjkFyMzkiK0vfhJOcDBzX+2HGEdxlmLNN/HNgQ5QcUVICV65ArskReXnoc300UAMsiohZOQRnQc3Tm41zRG6ujiHodlZV6TgDuu9ONawSIBuCPaDiIS9Kjpg4Ea5d032stBToCxwC9ps+kQqMNX1jmo4/zeSIjRthyBB9noHmFhXpc69V6oAJS+tqagY0PGLnVkb/02LnucCS7K0lViSzpRt+fMx8P+tqLMnepLIke5PKkuxNKkuyN9vtjCxOLcOkgPo27nNT/Z6x81xg2ea90wLrpvdjZEWqNUseSY6ZCyzbPBdYtnkusGzzXGDZ5rnAss2TyopF3WYACrAlhvoq8oXZsfNcYNnmPdMC65kW9g8/W70a3ZGbY4WlgNdb4EqOmQss2zwXWLZ5LrBs81xg2ea5wLLNk8qKSR3wi7l1Rf4EX2/Kcdr+PO0+Zr8wQ4Vi57nAag9vv4zC+mULrAbPVqfhTwZhluLm0polj6THrLuzJHuTypLsTSpLsjepLMnepLIke7PdzsjS7e+C/zP6er7ltxCoPmb/alB1A2+N5wJLirfl3Dz4DJd6UPUDI04q828detDaGp/dMWZdiSXZm1SWZG9SWZK9SWVJ9iaVJdmb7XaGS7cfgNouGzZ4Vlfx1uDZ6tw8AL24IeKk4tZOqu4Ss67KkuxNKkuyN6ksyd6ksiR7k8qS7M0mq/svw2RZI0Z4Vmfy2sJq7kaiAOg7Qq+wtfYWPUH3iVlXZdnmucCyzXOBZZvnAss2zwWWbZ5UVmvUrW5CulWdOOFZnclrC6u5G4kUcMnHrNuwbPNcYNnmucCyzXOBZZvnAss2TyqrVeqAX8ytq71+gh8wwLO6irfmrgGtA1XoY9ZtWJK9SWVJ9iaVJdmbVJZkb1JZkr3ZZPlrQNtYQiHP6ireIu+Cb+pGo70+Zt2GJdmbVJZkb1JZkr1JZUn2JpUl2ZtNllML0Xu5pcvABPSTO19DL0T/mtmeQNsWsffy8vLy8vLqWPmbkCJ0/RnlntUpvLayLhP9RiMfs+7Dss1zgWWb5wLLNs8Flm2eCyzbPKms1sjPgEboyhXP6kyeCyzbPBdYtnkusGzzXGDZ5rnAss1zgWWbJ5XVKnXAJZvW5a8BlcGS7E0qS7I3qSzJ3qSyJHuTypLsTSpLsjepLMne/DWgXl5eXl5eXl5e3VsdMGFpXeEZ0DfQdz5fBpUS4yg9xexfD6o+6dZ4Nln3gzrfiHXevN6Zvlxpp+SYucCS7E0qS7I3qSzJ3qTmRskxk8qS7M12O8Ol2y/DVEvEs79jCFhKxL4KlFoTO88m6/4WWG1JQDZ9udJOyTFzgSXZm1SWZG9SWZK9Sc2NkmMmlSXZm+12RhZnBqDhgF1uY4DCo/4wQ4Vi59lknW+Bdb6TfHV0O+tp/TPcpR5Lyd6ksiR7k8qS7E0qS7I3V74DXGBJ9ma7nZHFuWtAe8VQP4h8oSZ2nk3WgBZYAzrJl21ec+0MTBmMXtvzINCng3xJjpkLLNs8F1i2eS6wbPM6+juguXzYXr5s81xg2eZJZcWirr0OaBnQG8iCoAhUMhQeh+Ji2LpVV9m+HXr2hNmz9XZODjz+OIwYAZxALyK50/C+A0wBcvVBUXmwJhdGj4aaGli0CHbt0lXLy+HsWZg3z+w7H5gJpALngC8BIf1WEAJVBaHFenvJEpg6FcaPh4sXITsb9uyB+Hh44QXgKLDCcAuAk4Z1DYJMUKUQ6guHDsGBA7BuXQ9ui+vBa+sUf/f+txkwDd4CitKAHcBA4AiwG7jPsDZCMARUht7MzIRNmyApCSor4dlndRwBtmyB/v0hK8t4ygZWA0OB3wCDgO0mZjsgzcQZYM4cWLAARo6EU6dg1aqItcZKgVogz2w/Zto7BjhjYloOPYCP7IbN1XDnAl114ULIyICxY+H8eSDnRrzZa9oajv8yUJMg9BBcuqTbUV4OCQk6focPQ0GBrvvEE+YYTgbqgOnAuw3rJQieB7VOb27YoPtRWpreNz0dtm2DQYPg6FEoK9MxBWAzkAhkohvUC3gSgsGgXoGkbTrOoBm9e+t+AbrvLl8Ow4cDVcB6c1wBvg1MA+aY+D8KhfkwahScPg1Ll0Jpqa5aVqZjlZ9v9p0LzAJSgLPAooiYVYA6CaHH9Pbixbqd48bBhQvaU0UFxMXBvn1AJbDMcFcCvzOsqxDMALULQr3gxRfh4EFYs0ZXLSyEMWNgyhSor9cx3LkT/Q172DA2mJiNB4ZBkK7/xI6frvtoYiIcOwbPPQfPPKO5xcUwcCDMnGk8ZQFFQDLwa3MstpqYbYf0KDnixAlYu9Z4AigBrgC5ZnsBsAYYDUENqEUQipIj5s/XflJT4dw5w6gwnBDw7xHxXwJqKoSi5IijR2GFyREFBfq4MBG4hu5jpUB/428/BIU6ZmPX6b4xbZreNy0NduzQsTpyBHbvhqefNp42AkOADBP/BGATBEmgKmFwMzkiOxtWr4ahQ4FXDWu74f4bJkmY+M+BdVFyRGkp1NZCXjhH5ANf4EaOWBoRs92gqiEUJUfk5EDI1N27F44fB5YY7jJgEjo/lqK/U8pBJUB+EzkiNRUmT4a6Opg+3fjtB7wEPA+sMzEbB4yAIE3HP66ZHLF5s+7LmZnG0wzgSfRf4b8CkoAtJmbb4F96Q+8mckRVFaxfr48roL/f3gbmmO35QCEwCoLToJZCKEqOmDsXZs2ClBTdl/PzgT2GU4H+brrPHIPFpp3jYGcTOaKyEpaZHLFyJUyYADwMXDVt3QX0BeYBByFYo2OWGiVHDBigj0sopHMxAE8Bw4B0E/94oBiCRFDHILmZHJGVBUVFkJwMHNf7YcYRPGeYs038c2BDlBxRUqKXM8o1OSIvD32uj0YP8BZFxKwcgrOg5unNxjkiN1fHEHQ7q6p0nAHdd6caVgmQDcEeUPGQFyVHTJwI167pPlZaauJ9CNhv+kQPYKzpG9N0/GkmR2zcCEOG6PMMNLeoSJ97rVIH/GJuXdF+gq9v4xRxg6nnJqaf28LrLFZcXJwaOXiw+p/evW96NnpdG1mS2tm4hH+O72xfkmPWXViSvUllSfYmlSXZW0u5saV86GMmhyXZm+12RhbnfoK/GkN9ZYlnk3WhBdaFRtuff+MN3n/lCj0avd6DG73Bhq9w/Y5qZ6QC4J4WPlfisbTNc4Flm+cCyzbPBZZtXkfmxpbyYePPdSFmUlm2eVJZsajLD0AjB1gPtXHfcP3rjPLYeTZZ41tgjY+oW19fz8w337xp8BlW+PoOG74i67dXO6NJAa93kC+bLMnepLIke5PKkuxNKkuyt/GNX2iUG1vKh+3lyzbPBZZkb7bb2WZ1wC/m1tVu64A+fGs8m6wGa8A9fOPOx6aW32j803vjUmfRV0e0M1oblnfRYynZm1SWZG9SWZK9SWVJ9vYMEfnw4bbnQxdjJpUl2ZvtdoZLt1+GyXaR+kirlljVRB98Nr5WSPIjxfaGUC/T8NrVerP9Mi0vxdQVjqVkb1JZkr1JZUn2JpUlzVsfUD8PAp0PQ7eWD12JWVdgSfbmH8Xp1WZ9E3gnynv15v2uoHeACegb4V8z26+Z7QnA5c6x5eXl5dXhugx8QikK0Kua+Hzo1e3UAROW1tVeM6BDh3ZNVh9aP3No01dXjllnsSR7k8qS7E0qS7I3qSzJ3qSyJHuTypLszSbLz4C2UdfXDOxirMu0fubQpi/bPBdYtnkusGzzXGDZ5rnAss1zgWWb5wLLNk8qqzXq2gvRW1ZqatdlXUavqb/WAqst6sox6wyWbZ4LLNs8F1i2eS6wbPNcYNnmucCyzZPKao38DGiEzp3zrM7kucCyzXOBZZvnAss2zwWWbZ4LLNs8F1i2eVJZrVGglFId+5G3rosXL9K/f3/r3Lg4/agvz+ocngss2zwXWLZ5LrBs81xg2ea5wLLNc4FlmyeVVVtbS79+/Zr/PDsf1T0UfuaqZ3UOzwWWbZ4LLNs8F1i2eS6wbPNcYNnmucCyzZPKao38ANTLy8vLy8vLy6tD5QegEQqFPKszeS6wbPNcYNnmucCyzXOBZZvnAss2zwWWbZ5UVqvU7ot2toPa7VGc4yw+0qqbsiR7k8qS7K3Bo1DHNf/IVx8z2SzJ3qSyJHuTypLsTSpLsjfb7QyXbv8ozlpuLLpeH0PAUiL2VaBUKHaeCyzJ3qSyJHu7vwVWWwahrsRMKkuyN6ksyd6ksiR7k8qS7M12OyOLMwvRB+bfQ23cL1w/aPR6LDwXWLZ5LrBs82yyXmqB9RKtlysxk8qyzXOBZZvnAss2zwWWbZ5UVkzqgAlL62o8Axo5YqcNpT5ifwVKjYyd5wJLsjepLMnepLIke5PKkuxNKkuyN6ksyd6ksiR7s93OyNKaGdCu/SSkMqA3kAVBEahkKDwOxcWwdauusn079OwJs2fr7ZwcePxxGDECOIF+dNBOw6sFdgG5+i8AlQdrcmH0aKipgUWLYNcuXbW8HM6ehXnzzL7zgZlAKnAO+F9gnX4rCIGqgtBivb1kCUydCuPHw8WLkJ0Ne/ZAfDy88AJwFFhhuAXASvTtYtcgyARVCqG+cOgQ7N8PhYW66rp1MGoUTJumt9PSgB3AQOAIsBv4LnAS2AjBEFAZEAIyM2HTJkhKgspKePZZHUeALVugf3/IyjKesoHVwFDgDmAGsN3EbAekmTgDzJkDCxbAyJFw6hSsWgUlJYZTamKeZ7b/G6gDxkBwBtR8CJXrt3bvhupqzQJYuBAyMmDsWDh/HshBNwRgL/BhYIiJ/zJQkyD0EFy6pNtRXg4JCXDgABw+DAUFuu4TT5hjONl4mQ78G/rZpi9B8DyodfqjNmzQ/SgtTe+bng7btsGgQXD0KJSV6ZgCsBlIBDKBYcBHgSchGAzqFUjapuMMmtG7t+4XoPvu8uUwfDhQBaw3xxXggjmuc0z8H4XCfN0PTp+GpUuhtFRXLSvTscrPN/vOBWYBKcBZ4BQ3+mwFqJMQekxvL16s2zluHFy4oD1VVOh14/btAyqBZYa70vSPALgKwQxQuyDUC158EQ4ehDVrdNXCQhgzBqZM0evPpafDzp3AAOCwOaYbTMz+Sf8bpOsMFz9d99HERDh2DJ57Dp55RnOLi2HgwIhHy2UBRUAy0Afdh7eamG2H9Cg54sQJWLvWeAIoAa4AuWb7l2gzoyGoAbUIQlFyxPz52k9qqlnwOReoMJwQ8BFgsIn/ElBTIRQlRxw9CitMjigo0MeFicA1dB8r1Z7YAeyHoFDbHNtEjtixQ8fqyBF9nj39tPG0EX0OZZj4PwBsgiAJVCUMbiZHZGfD6tUwdCjwqmFtN9w/A/8B5Jj4z4F1UXJEaSnU1kJeOEfkA18AxgBngGpu9NndoKohFCVH5OTcuMli7144fhxYYrjLgEnaE6+gv1PKQSVAfhM5IjUVJk+GujqYPt347Yf+2eB542mYOcYjIEjT8Y9rJkds3qz7cmam8TQDeNL0id7AbGCLidk2yIiSI6qqYP16fVwB/f32NjDHbL8C9ABGQXAa1FIIRckRc+fCrFmQkqL7cn4+sMdwKtDfJd8w/y427RwHO5vIEZWVsMzkiJUrYcIE4GHgqmnrLu2J7cBBCNbomKVGyREDBujjEgrpXAzAUybu6ebfvwKKIUgEdQySm8kRWVlQVATJycBxvR9mHMGf0N8rs038c2BDlBxRUgJXrkCuyRF5eaYfjAZqgEXc+B4uh+AsqHk6BTTOEbm5N5ZGCoX0scWMI1gCTDX9ohLIhmAPqHjIi5IjJk6Ea9d0HystBfqipzn3A4UmZnNM35im408zOWLjRhgyRJ9noLlFRfrca5U6YMLSutptBjRk8S+JbsiS7E0qS7I3qSzJ3qSyJHuTypLsTSpLsjepLMnebLczsjhzDWhYV2OoryJfuBg7zwWWbZ4LLNs8F1i2eS6wbPNcYNnmucCyzXOBZZsnlRWTOmDC0roiZ0DrI8qt3JkW/ksgVp4LLMnepLIkeztLo79+afjX71kfsy7DkuxNKkuyN6ksyd6ksiR7s93OyNLtl2F6wwTJ2tpce26N5wJLsjepLKne6mg08NzTcLvOx6xLsSR7k8qS7E0qS7I3qSzJ3my3M1y6/QDUdgmFPKu7eJPKkuStmuav/6kW0kZJMesqLMnepLIke5PKkuxNKkuyN5ss564BvVW98IJndSbPBZZt3q2wvgm80wB247/15v1Y1V1j1lVYtnkusGzzXGDZ5rnAss2TymqN/AA0QkePelZn8lxg2ebdCmsTevWOd9B/snJU//uOeX1TJ/lqb54LLNs8F1i2eS6wbPNcYNnmSWW1Sh3wi7l1+Z/gZbAke5PKkuatD6jl6J/b60P63+XmdSltlBazrsCS7E0qS7I3qSzJ3qSyJHvzP8F7eXl1mC6jn8UwBPhP8+9a87qXl5eXl1e7qQMmLK2rvWZAx4zxrO7iTSpLsjepLMnepLIke5PKkuxNKkuyN6ksyd5ssvwMaBs1bpxndSbPBZZtngss2zwXWLZ5LrBs81xg2ea5wLLNk8pqjfwANEITJ3pWZ/JcYNnmucCyzXOBZZvnAss2zwWWbZ4LLNs8qazWyA9AI3Ttmmd1Js8Flm2eCyzbPBdYtnkusGzzXGDZ5rnAss2TymqNAqWU6tiPvHVdvHiR/v37d7YNLy8vLy8vLy+vRqqtraVfv37N1unSM6BvoBfMvgykxMhIMfvXA/Wlt8ZzgSXZm1SWZG9SWZK9SWVJ9iaVBXA/cL4R77x5HaAPsByoBurMv8vN6+3pTSrLNq+l+HeWL8kxk8pqs9r9lvV2UPgu+FpuPDawnrY/uzQlYl/FjUcRxsJzgSXZm1SWZG9SWZK9SWVJ9iaVBaj7W8F7GVRd+H1T6szrkevlSm2n5H7WUvzv9zHrMqzGpds/Cz48AA0H7HIbA3Q5MvCg1ILYeS6wJHuTypLsTSpLsjepLMnepLIAdb4VvMaDz3CpQz+0QXo7JfezluJ/3sesy7AaF+cGoPVtDFCDwINSo2LnucCS7E0qS7I3qSzJ3qSyJHuTymotT0Up9egnh0lvp+9nPmYd1c7I0poBaDxdWWVAbyALgiJQyVB4HIqLYetWXWX7dujZE2bP1ts5OfD44zBiBHAC/diXnYaXCBQAuRAAKg/W5MLo0VBTA4sWwa5dump5OZw9C/PmmX3nAzOBVOAcMOiGzSAEqgpCi/X2kiUwdSqMHw8XL0J2NuzZA/Hx8MILwFFghdm5APhX4LfANQgyQZVCqC8cOgT790Nhoa66bh2MGgXTpunttDRgBzAQOALsBg4Y/kYIhoDKgBCQmQmbNkFSElRWwrPP6jgCbNkC/ftDVpbxlA2sBoYCI4EHge0mZjsgzcQZYM4cWLAARo6EU6dg1SooKTGcUqAWyDPbvYCfAGMgOANqPoTK9Vu7d0N1tWYBLFwIGRkwdiycPw/koBsCsNd4vGDivwzUJAg9BJcu6XaUl0NCAhw4AIcPQ0GBrvvEE+YYTkZf8DUd+L/AL4CXIHge1Dr9URs26H6Ulqb3TU+Hbdtg0CD9TN2yMh1TADaj+1em4Q8FnoRgMKhXIGmbjjNoRu/eul+A7rvLl8Pw4UAVsN4cVwxzDTDHxP9RKMzX/eD0aVi6FEpLddWyMh2r/Hyz71xgFvpin7PAPejUAQQVoE5C6DG9vXixbue4cXDhgvZUUQFxcbBvH/rh8csMdyXwb8Ap4CoEM0DtglAvePFFOHgQ1qzRVQsLYcwYmDIF6ut1DHfuBAYAh80x3WBilgkMgyBd24yfrvtoYiIcOwbPPQfPPKO5xcUwcCDMnGk8ZQFFQDLwAWACsNXEbDukR8kRJ07A2rXGE0AJcAXINdu3Az8DRkNQA2oRhKLkiPnztZ/UVDh3zjAqDCcEfB74s4n/ElBTIRQlRxw9CitMjigoMOv3TQSumTiVAg8DTwL7ISjUMRvbRI7YsUPH6sgRfZ49/bTxtBH9aKwME//7gE0QJIGqhMHN5IjsbFi9GoYOBV41rO2Ge7c5Fjkm/nNgXZQcUVoKtbWQF84R+cAXgDHAGWAw+qI1INgNqhpCUXJETg6ETI7YuxeOHweWGO4yYBKwCHgR/Z1SDioBnTMPo3MxgMkRwWS41+SIkhKgH/AS8DywzsQsAxgBQZqOf1wzOWLzZt2XMzPN58wwx28wus8+DGwxMdsGGVFyRFUVrF+vjyugv9/eBuaY7duBY8AoCE6DWgqhKDli7lyYNQtSUnRfzs8H9hhOBXASKEd/pyw27RwHO5vIEZWVsMzkiJUrYcIE06arpq27gIdM7A5CsEbHLDVKjhgwQOfuUEjnYgCeAoYB6Sb+g4FiCBJBHYPkZnJEVhYUFUFyMnBc74cZR3AXOu/ONvHPgQ1RckRJCVy5ArkmR+Tloc/10UANuo+Fv4fLITgLap5OAY1zRG6ujiHodlZV6TgDuu9OBRYCPwCyIdgDKh7youSIiRP1ne6ZmeZ7oS9wCNgPFJqY/b3pG9PM10EzOWLjRhgyRJ9noLlFRfrca5U6YMLSutptBjRk8S+JbsiS7E0qS7I3qSzJ3qSyJHuTymotT0UpLc6ACmmn72c+Zh3Vzsji3E/wt3xdxtjYeS6wJHuTypLsTSpLsjepLMnepLKgiWsQm+DFfA2okHZK7mctxf+WrgHtpjGTympcnHgUZ7i1oGfv26Jw/euMUbHzXGBJ9iaVJdmbVJZkb1JZkr1JZQGMbwWvEngn4jVltiuBTe3kTSrLNq+08QujWni/g3xJjplUVkzqgAlL6wrPgL7BjVF6rMsFpHDjr4D60K3xXGBJ9iaVJdmbVJZkb1JZkr1JZYFe6ud8I955biwB1Ac901mNnvWsNtt9mmBJbafUflZNo5nlRj8BV7eR50LMJLMiS7f/Cd52CYU8q7t4k8qS7E0qS7I3qSzJ3qSyJHuTyrpV3k2XN4QabtcJaaekmHUVVmsGoP5RnF5eXl5eXl4drmr0jepNSQGvoRdi8Op66vaP4rSt68tWeFan8Fxg2ea5wLLNc4Flm+cCyzbPBdat8r6Jvp72BuzGf+vN+7Gqu8asq7BaIz8AjdDAgZ7VmTwXWLZ5LrBs81xg2ea5wLLNc4F1q7xNNLrJa6D+t6mbvDrSV3uybPOkslojPwCN0JEjntWZPBdYtnkusGzzXGDZ5rnAss1zgXWrvMvoZ0IUoH9urz+i/y0wr1/uJF/tybLNk8pqldr9jqF2UHvdhDR8uGd1F29SWZK9SWVJ9iaVJdmbVJZkb1JZkr1JZUn2ZpPl74JvY5F6N5lUlmRvUlmSvUllSfYmlSXZm1SWZG9SWZK9SWVJ9tbRd8H7n+C9vLy8vLy8vLw6Vh0wYWld7TUD+tBDntVdvEllSfYmlSXZm1SWZG9SWZK9SWVJ9iaVJdmbTZafAW2jhlhccMwFlm2eCyzbPBdYtnkusGzzXGDZ5rnAss1zgWWbJ5XVKnXAhKV1NX4UZ+Rj09paWnoMm2d1HW82WfeBOtGIdcK87mPm+5lElmRvUlmSvUlldZS3URZZrsSss1mRpdvfhFTLjWfG1scQsPsj9lXceAxYLDwXWJK92WTdh34EXFOsd0C9TsvPhO4K7ZTKkuxNKkuyN6ksyd6kslrDe4aWc6L0dvp+Fls7I4szA9BwwM63MUDhUX+YoRJi57nAkuzNJutkCywVUepA/TwImk24UtsplSXZm1SWZG9SWZK9SWW1xAszX6Z1g1Cp7fT9LLZ2RhbnBqD1bQxQ48GE2hI7zwWWZG8dxWqq1IFaIcBbd2FJ9iaVJdmbVJZkb1JZLfHCpQ7961BXbafvZ7G1M7K0ZgAaT1dWGdAbyIKgCFQyFB6H4mLYulVX2b4devaE2bP1dk4OPP44jBgBnADWAjsNLxGYAuRCAKg8WJMLo0dDTQ0sWgS7dumq5eVw9izMm2f2nQ/MBFKBc8AgIKTfCkKgqiC0WG8vWQJTp8L48XDxImRnw549EB8PL7wAHAVWGG4B8KBhXYMgE1QphPrCoUOwfz8UFuqq69bBqFEwbZreTktDP1t3IHAE2A2kA0nARgiGgMrQ6MxM2LQJkpKgshKefVbHEWDLFujfH7KyjKdsYDUwFBhp2rrdxGwHpJk4A8yZAwsWwMiRcOoUrFoFJSWGUwrUAnlmu5dp7xgIzoCaD6Fy/dbu3VBdrVkACxdCRgaMHQvnzwM5N+LNXmBURPyXgZoEoYfg0iXdjvJySEiAAwfg8GEoKNB1n3jCHMPJQB0wHfiMidlLwPPAOvM5G4AREJcGXwYK02HbNhg0CI4ehbIyHVMANqP7V6bhLwSehGAwqFcgaZuOM2hG7966X4Duu8uXw/DhQBWwnhvPTE4EpgFzTPwfhcJ83Q9On4alS6G0VFctK9Oxys83+84FZgEpwFngnoiYVYA6CaHH9Pbixbo/jRsHFy5oTxUVEBcH+/ahn5u3zHBXAuMN6yoEM0DtglAvePFFOHgQ1qzRVQsLYcwYmDIF6ushPR127gQGAIcNY4OJWRkwDIJ0neHip+s+mpgIx47Bc8/BM89obnGxfqzczJnGUxZQBCQDHzBx22pith3So+SIEydg7VrjCaAEuALkmu3bgTXAaAhqQC2CUJQcMX++9pOaCufOGUaF4YSAD0XEfwmoqRCKkiOOHoUVJkcUFOjjwkTgGrqPlQIPo3PcfggKdczGNpEjduzQsTpyRJ9nTz9tPG0EhgAZJv7zgU0QJIGqhMHN5IjsbFi9GoYOBV41rO2GezcmSZj4z4F1UXJEaSnU1kJeOEfkA18AxgBngMERMdsNqhpCUXJETg6ETN29e+H4cWCJ4S4DJqHzY3/0d0o5qATIbyJHpKbC5MlQVwfTpxu//WiYI1LNcRgBQZqOf1wzOWLzZt2XMzONpxnAk6aNH0DnoC0mZtsgI0qOqKqC9esjnuu9E3gbmGO2bwcKgVEQnAa1FEJRcsTcuTBrFqSk6L6cnw/sMZwK4CQ3vlMWm+M6DuIuwCOz4YGIHFFZCctMjli5EiZMQPfRq6atu4CH0DnuIARrdMxSo+SIAQP0cQmFYMMG4+kpYJjxlIrOccUQJII6BsnN5IisLCgqguRk4LjeDzOO4C7DnG3inwMbouSIkhK4cgVyTY7Iy0Of66OBGmBRRMzKITgLap7uxo1zRG6uzrOg21lVZeIMuu9ONaw7gGwI9oCKh7woOWLiRLh2Tfex0lKgL3AI2G/6RCo6x42CYJqOP83kiI0b9Y1LGRl6OzNTx3DhQlqnDpiwtK6mZkDDI3ZuZfRfEDvPBZZkbx3JaqrUCfHWHViSvUllSfYmlSXZm1RWa3jh0lxOlN5O389ia2dkce4n+NZ0+MhS1zj4g2PnucCS7M0m6+1mWE2VevQNSV2tnVJZkr1JZUn2JpUl2ZtUFjRx3WAT+bGlnCi9nb6fxdbOyOLcOqBbYqivIl8ojp3nAss2TyrrmRZYjVUPfLOZ96W2UyrLNs8Flm2eCyzbPBdYoK+ugRsjjabyY0s5sT28SWXZ5kllxaQOmLC0rsgZ0PCFssdp/dIP4dLH7BdmqFDsPBdYkr3ZZv0yCuv6a9z4C7GlOz4lt1MiS7I3qSzJ3qSyJHuTygqXptaOVLQ+J0pvp+9nsfeNcOn2P8H/mdavxdjcAVhuOHWTb43nAkuyt/ZmrTGlmratA9rV2imBJdmbVJZkb1JZkr1JZTXm7pwcW06U3k7fz26tb7TLAPTQoUNq2rRpKjExUQGqoqKiwfv19fVqxYoV6u6771a33367+uQnP6n+93//t0Gd8+fPq3/4h39Qd9xxh+rfv7/KyclRb775Zqs9tNez4DMzPau7eJPKkuxNKkuyN6ksyd6ksiR7k8qS7E0qS7I3m6x2uQb08uXLjB49mq9//etNvr9hwwaeeeYZtm7dys9+9jP69OnD5MmTeeutt67XycrK4le/+hUHDhxg7969/Nd//RePPPJIW61Y1/VlhjyrU3gusGzzXGDZ5rnAss1zgWWb5wLLNs8Flm2eVFZr1OZ1QD/96U/z6U9/usn3lFJ89atfZfny5aSlpQHw3HPPcdddd/Ef//EfzJgxg1dffZXvf//7vPzyy6SkpADwta99jSlTpvDUU09xzz333EJzvLy8vLy8vLy8xKvVv3s3IWj4E/zJkycVoCorKxvU+8QnPqHmzp2rlFLq2WefVe9617savP/222+rHj16qH//939v8nPeeustVVtbe73U1NRYnQ4Pl379PKu7eJPKkuxNKkuyN6ksyd6ksiR7k8qS7E0qS7I3m6wOX4bp97//PQB33XVXg9fvuuuu6+/9/ve/Z9CgQQ3ej4+P593vfvf1Oo31la98hf79+18vgwcPtmn7ulav9qzO5LnAss1zgWWb5wLLNs8Flm2eCyzbPBdYtnlSWa1Rl1gH9Mtf/jK1tbXXS01NTbt8ztChntWZPBdYtnkusGzzXGDZ5rnAss1zgWWb5wLLNk8qqzWyOgC9++67AfjDH/7Q4PU//OEP19+7++67OXfuXIP36+rq+POf/3y9TmMlJCTQr1+/BqU99OqrntWZPBdYtnkusGzzXGDZ5rnAss1zgWWb5wLLNk8qq1Vq21WfDQUNrwGtr69Xd999t3rqqaeuv1ZbW6sSEhJUWVmZUkqp//mf/1GAOnbs2PU6L7zwggqCQJ05c6ZVn9teyzANGuRZ3cWbVJZkb1JZkr1JZUn2JpUl2ZtUlmRvUlmSvdlktcs6oG+++aaqrKxUlZWVClAbN25UlZWV6vTp00oppdatW6fe9a53qVAopH75y1+qtLQ09d73vlddvXr1OuNv//Zv1ZgxY9TPfvYz9eMf/1i9733vUzNnzmy1h/YagIZCntVdvEllSfYmlSXZm1SWZG9SWZK9SWVJ9iaVJdmbTVZrBqBtXobp2LFj/M3f/M317QULFgDwuc99jp07d7J48WIuX77MI488whtvvMGDDz7I97//fW6//fbr+5SWlpKfn88nP/lJ4uLimD59Os8880xbrXh5eXl5eXl5eXVFtXUGVILCM6BvoJ9ZehlUSoyj9BSzfz2o+rRb47nAkuxNKkuyN6ksyd6ksmzzGjzvO+3GM6LP0vZH9TXFOm9et+ErVpbk4ymVJdmbVJZtns1zwHY7w6XbPwu+FpQKBy6GgKVE7KtAqbTYeS6wJHuTypLsTSpLsjepLNu8+6OwwqUO1Mu0bhAajRV+rS1fmjZZko+nVJZkb1JZHXVuxnIO2G5nZHFmABoO2OU2Big86g8zVCh2ngssyd6ksiR7k8qS7E0qyzbvfDOscKlDz4TeCqvecOpAVdPyzGpLrPOdGDMXWJK9SWV15LnZ1nPAdjsjS4cvRN/Z6hVD/cASzwWWbZ4LLNs8F1i2eS6wbPMGtMACvYbfIxZYPUwZDBQAB4E+MbIGtMJPpKQeT6ks2zwXWLZ5Ns8B2+1sq9p8E5IolQG9gSwIikAlQ+FxKC6GrVt1le3boWdPmD1bb+fkwOOPw4gRwAlgLbDT8L4HTAFy9UFRebAmF0aPhpoaWLQIdu3SVcvL4exZmDfP7DsfmAmkAuc0g5B+KwiBqoLQYr29ZAlMnQrjx8PFi5CdDXv2QHw8vPACcBRYYbgFwE8N6xoEmaBKIdQXDh2C/fuhsFBXXbcORo2CadP0dloasAMYCBwBdgMJhrURgiGgMvRmZiZs2gRJSVBZCc8+q+MIsGUL9O8PWVnGUzawGhgKnAYGAdtNzHZAmokzwJw5sGABjBwJp07BqlVQUmI4pUAtkBfR1gJgDARnQM2HULl+a/duqK7WLICFCyEjA8aOhfPngZwb8WYvsC0i/stATYLQQ3Dpkm5HeTkkJMCBA3D4MBQU6LpPPGGO4WSgDpgO/MWwXoLgeVDr9OaGDbofpaXpfdPTYds2GDQIjh6FsjIdUwA2A4lApjkGvYAnIRgM6hVI2qbjDJrRu7fuF6D77vLlMHw4UAWsN8cVoAKYBswx8X8UCvN1Pzh9GpYuhdJSXbWsTMcqP9/sOxeYBaQAZ4F/iohZBaiTEHpMby9erNs5bhxcuKA9VVRAXBzs2wdUAssMdyXwsmFdhWAGqF0Q6gUvvggHD8KaNbpqYSGMGQNTpkB9vY7hzp3oLHrYMDaYmI0HhkGQrv/Ejp+u+2hiIhw7Bs89B+F7GYuLYeBAmDnTeMoCioBk4LfmWGw1MdsO6VFyxIkTsHat8QRQAlxBn9/htq4BRkNQA2oRhKLkiPnztZ/UVDgXzhEVhhMCtkfEfwmoqRCKkiOOHoUVJkcUFOjjwkTgGrqPlZqYLQD2Q1CoYza2iRyxY4eO1ZEj+jx7+mnjaSMwBMgwrARgE5Ckj3fwLNxbrC03zhHZ2fqpKkOHAq8a1nbD3YNJEubLb47xORJ6nIIxq+BYCfwvuu/W1kJeOEfkA18AxgBnzHY4ZrtBVUMoSo7IyYGQqbt3Lxw/Diwx3GXAJNPGUt1fgnJQCZDfRI5ITYXJk6GuDqZPNzmtH/AS8DywzrDGASMgSNPxj2smR2zerPtyZqbxNAN4Ej0yP2HivsX02W2QESVHVFXB+vX6uAL6++1tE2eA5UAhMAqC06CWQihKjpg7F2bNgpQU3Zfz883xA913T3LjO2Wxaec42NlEjqishGUmR6xcCRMmAA8DV01bdxnWPOAgBGt0zFKj5IgBA/RxCYV0LgbgKWAYkG5Y8UAxBImgjkFyMzkiKwuKiiA5GTiu98OMI/iuYc428c+BDVFyREkJXLkCuSZH5OWhz/XRQA2wKCJm5RCcBTVPbzbOEbm5Ooag21lVpeMM6L471bBKgGwI9oCKh7woOWLiRLh2Tfex0lKgL3AI2G/6RAIw1vSNaTr+NJMjNm6EIUP0eQaaW1Skz71WqQN+MbeuaD/B17dxirjB1DMotS52ngssyd6ksiR7k8qS7E0qqyO9RTKrLbFay+2qMesuLMnepLIkeeuDvsylGn3Zi+12RhbnfoK/GkN9FfnCyNh5LrBs81xg2ea5wLLNc4Flm3ehBRZAPfBNS6xIBcA9MbIutMJPpKQeT6ks2zwXWLZ5sZ4D/eLi+K8goAA9qd4DM5tryVcs6vID0PBwG+ChNu4brn+dcSp2ngssyd6ksiR7k8qS7E0qyzZvfBRW+LV30FddbLpFVlNSwOttZKlG77dWUo+nVJZkb1JZtnmxngOL4uMZrRQ9Gr0eHoTaaGeb1f4/mNtXu60D2u/WeC6wJHuTypLsTSpLsjepLNu8BmsN9rvxk9wtrwMawVJNlJburm+KZW0dUEHHUypLsjepLNu8WM6B14Kg2ctebLUzXLr9Mky2i9RHWkllSfYmlSXZm1SWZG9SWZK9hUJ68PoyDa9Dq6dt64s29tUX1MogUDW0flmnrhQziSzJ3qSyOstbHc1fe11n2Zdz14B6eXl5ecnXZWACetGL19A/6b9mtieY99uiPujlm1Yqxb20flknLy9XFO2yFtAjxubeby/5AWiEwsvVeFbn8Fxg2ea5wLLNc4Flm9cerMvoVfCGoFfLGWK22zL4DLPmA38FN13f1gO9YtP8NvJsyAWWbZ4LLNu81rK+if5DrymFbyi03c6W5AegEaqt9azO5LnAss1zgWWb5wLLNk866xFuHnyG1doF8yN5NuQCyzbPBZZtXmtZm9A3Dr6DnvHE/Bt5Q6HtdraoDrhk07r8NaAyWJK9SWVJ9iaVJdmbVJZkb+3Bas31bd2hndJYkr1JZXWmt8brgDa+TrqjrwHt2k9C8vLy8vJyXq+jr/lsSorOub7Ny0uawpe9rO1sI2F1wISldbXXDOjgwZ7VXbxJZUn2JpUl2ZtUlmRv7cFaTvRZ0JaWdepK7ZTGkuxNKkuyN5ssfxd8G/WFL3hWZ/JcYNnmucCyzXOBZZsnnbWJlq9v6yxv3Zllm+cCyzZPKqs18gPQCI0Z41mdyXOBZZvnAss2zwWWbZ50lq1lnaS3UxrLNs8Flm2eVFZr5K8BjdCZM57VmTwXWLZ5LrBs81xg2eZ1BZaN69u6QjslsWzzXGDZ5klltUodcMmmdbXbozgTLD66q5uyJHuTypLsTSpLsjepLMnepLIke5PKkuzNJqvB4y4TLD/yVVA7bfeNcOn2j+KspeFzTNsasJSIfRUoFYqd5wJLsjepLMnepLIke5PKkuxNKkuyN6ksyd5ssu5vgdXWQajUdtruG5HFmZuQAvPvoTbuF64fNHo9Fp4LLNs8F1i2eS6wbPNcYNnmucCyzXOBZZsnlfVSC6zjQDWwnNY95lVqO233jbaqWwxAw+oVQ/0Ggd8dO88Flm2eCyzbPBdYtnkusGzzXGDZ5rnAss2TyhrQDCswZTD6JreDtDwIldpO232jreraNyGVAb2BLAiKQCVD4XEoLoatW3WV7duhZ0+YPVtv5+TA44/DiBHACfQV6zsN7+fAFCBXHxSVB2tyYfRoqKmBRYtg1y5dtbwczp6FefPMvvOBmUAqcA74NhDSbwUhUFUQWqy3lyyBqVNh/Hi4eBGys2HPHoiPhxdeAI4CKwy3AHgAyACuQZAJqhRCfeHQIdi/HwoLddV162DUKJg2TW+npQE7gIHAEXTnyjWsjRAMAZWhbWZmwqZNkJQElZXw7LM6jgBbtkD//pCVZTxlA6uBocAl4AVgu4nZDkgzcQaYMwcWLICRI+HUKVi1CkpKDKcUqAXyzPa/mfaOgeAMqPkQKtdv7d4N1dWaBbBwIWRkwNixcP48kHMj3uwFekbEfxmoSRB6CC5d0u0oL4eEBDhwAA4fhoICXfeJJ8wxnAzUAdNNezOAlyB4HtQ6jd6wQfejtDS9b3o6bNsGgwbB0aNQVqZjCsBmIBHINMdjN/AkBINBvQJJ23ScQTN699b9AnTfXb4chg8HqoD15rgCvAxMA+aY+D8Khfm6H5w+DUuX3ni+b1mZjlV+vtl3LjALSAHOAuURMasAdRJCj+ntxYt1O8eNgwsXtKeKCoiLg3370GvdLDPclSaGGcBVCGaA2gWhXvDii3DwIKxZo6sWFuo7L6dMgfp6HcOdO9HfAIeNnw0mZr8DhkGQrn/jiZ+u+2hiIhw7Bs89B888o7nFxTBwIMycaTxlAUVAMnAR+AGw1cRsO6RHyREnTsDatcYTQAlwBX0ehbfXAKMhqAG1CEJRcsT8+dpPaiqcO2cYFYYTQueycPyXgJoKoSg54uhRWGFyREGBPi5MBK6h+1ipaeudwH4ICnXMxjaRI3bs0LE6ckSfZ08/bTxtRD+gPcPEvxzYBEESqEoY3EyOyM6G1ath6FDgVcPabrhHMUnCxH8OrIuSI0pL9eMB88I5Ih/4AvoB72dM/MIx2w2qGkJRckRODoRM3b174fhxYInhLgMmAX8P/C36O6UcVALkN5EjUlNh8mSoq4Pp043ffuips+eBdSZmp4AREKTp+Mc1kyM2b9Z9OTPTeJoBPIke6bwBvAhsMTHbBhlRckRVFaxfr48roL/f3gbmmO1/BQqBURCcBrUUQlFyxNy5MGsWpKTovpyfD+wxnArgJDe+Uxabdo6DnU3kiMpKWGZyxMqVMGEC8DBw1bR1F3Av8G7gIARrdMxSo+SIAQP0cQmFdC4G4ClgGJBu4l8GFEOQCOoYJDeTI7KyoKgIkpPRU5zFgBlHcMQwZ5vtHOBx6DECPnIClq6FUTv1WyUlcOUK5JockZdnYjQaqAEWRcSsHIKzoObpbtw4R+Tm6hiCbmdVlY4zoPvuVOCz6L6bDcEeUPGQFyVHTJwI167pPlZaCvRFT3PuN31iIHpcNAqCaTr+NJMjNm6EIUP0eQaaW1Skz71WqQMu2bSuxteARl6zQBtKfcT+kdc/xMJzgSXZm1SWZG9SWZK9SWVJ9iaVJdmbVJZkbx3Falzq0Y+0lOCts/tGZHHmGtCwrsZQX1niucCyzXOBZZvnAss2zwWWbZ4LLNs8F1i2eVJZF1pgRSoA7mmhjtR22u4bbVYHTFhaV+QMaH1EuZW7+epBqeGx81xgSfYmlSXZm1SWZG9SWZK9SWVJ9iaVJdmbTdb9TbAUsc+ASm2n7b4RWbr9MkxvmCBZW89sya3xXGBJ9iaVJdmbVJZkb1JZkr1JZUn2JpUl2ZtNVoN1QA1LNVHqQC3vwu203TfCpdsPQG2XUMizuos3qSzJ3qSyJHuTypLsTSpLsjepLMnebLL2hlAvoweb4YFovdl+GVSfbtJOmyznrgG9VZ0/71mdyXOBZZvnAss2zwWWbZ4LLNs8F1i2eVJZ587DBPQiLa8B75h/C9CvX+5Eb1JZrVGglFId+5G3rosXL9K/f//OtuHl5eXl5eXl5dVItbW19OvXr9k6fgY0QuE14jyrc3gusGzzXGDZ5rnAss1zgWWb5wLLNs8Flm2eVFZr5AegXl5eXl5eXl5eHSo/AI3Q3r2e1Zk8F1i2eS6wbPNcYNnmucCyzXOBZZvnAss2TyqrNfID0AgdP+5ZnclzgWWb5wLLNs8Flm2eCyzbPBdYtnkusGzzpLJapXZfM6kd5JdhksGS7E0qS7I3qSzJ3qSyJHuTypLsTSpLsjepLMne/DJMXl5eXl5eXl5e3VsdMGFpXe01AzpqlGd1F29SWZK9SWVJ9iaVJdmbVJZkb1JZkr1JZUn2ZpPV7WdA3wDq0YvApsTISDH71wO/nHRrPBdYkr1JZUn2JpUl2ZtUlmRv9wEnGrFOmNc705dtngss27z7gfONWOfN653pS3LMpLLarA6YsLSu8AxoLTceiVVP259dmhKxrwKlQrHzXGBJ9iaVJdmbVJZkb1JZkr3dR8NHGEay3kE/c9vHrGuwbPPub4HVWX1DcsykshqXbj8DGlZg/j3Uxv3C9cP7cyl2ngssyd6ksiR7k8qS7E0qS7K3H6CXW2mKFQA/BwYmJHDfffcxfPhwBgwYQBAETZDciZlUlm3eSy2wXqL1ciVmUlmxqEs/irMW6GdeCzeiLSPqeiIC30ht5bnAss1zgWWb5wLLNs8Flm1eR7HCvPV9+lA5dSr9+vXjpz/9Ka+++ipKKerr69vNl22eCyzbPBdYtnlSWY3VmkdxxsfIlqEyoDeQBUERqGQoPA7FxbB1q66yfTv07AmzZ+vtnBx4/HEYMQJ9EdJaYKfh3Wm2c/VBUXmwJhdGj4aaGli0CHbt0lXLy+HsWZg3z+w7H5gJpALngP5Agn4rCIGqgtBivb1kCUydCuPHw8WLkJ0Ne/ZAfDy88AJwFFhhuAXAs0ANcA2CTFClEOoLhw7B/v1QWKirrlsHo0bBtGl6Oy0N2AEMBI4Au9F/0hwDNkIwBFQGhIDMTNi0CZKSoLISnn1WxxFgyxbo3x+ysoynbGA1MBR4P/AQsN3EbAekmTgDzJkDCxbAyJFw6hSsWgUlJYZTCtQCeWY7Dj0dMgaCM6DmQ6hcv7V7N1RXaxbAwoWQkQFjx8L580AOuiEAe4EZ3PhrbhmoSRB6CC5d0u0oL4eEBDhwAA4fhoICXfeJJ8wxnAzUAdOB3wGvAC9B8DyodfqjNmzQ/SgtTe+bng7btsGgQXD0KJSV6ZgCsBlIBDLRF9cMB56EYDCoVyBpm44zaEbv3rpfgO67y5fD8OFAFbDeHFeA9wBfAeaY+D8Khfm6H5w+DUuXQmmprlpWpmOVn2/2nQvMMn7Omn5ym4lZBaiTEHpMby9erNs5bhxcuKA9VVRAXBzs2wdUAssMdyX6nKoGrkIwA9QuCPWCF1+EgwdhzRpdtbAQxoyBKVOgvl7HcOdOYABw2BzTDcbjDGAYBOk6OcZP1300MRGOHYPnnoNnntHc4mIYOBBmzjSesoAiIBl4H/BJYKuJ2XZIj5IjTpyAtWuNJ4AS4AqQa7bjTNtHQ1ADahGEouSI+fO1n9RUOHfOMCoMJwT8/4E3TfyXgJoKoSg54uhRWGFyREGBPi5MBK6h+1gpMAF4GtgPQaGO2dgmcsSOHTpWR47o8+zpp42njcAQIMPEfyiwCYIkUJUwuJkckZ0Nq1fD0KHAq4a13XAHAk+iz1mAOfDPCy/z67/5Ly5cGMB//7eiouIdAP7t36C2FvLCOSIf+AIwBjgDDAJ6mpjtBlUNoSg5IifnxqMG9+41ax4uMdxlwCRgIXAQ/Z1SDioB8pvIEampMHky1NXB9Okmp/VDT9k9D6wzMcsERkCQpuMf10yO2LxZ9+XMTONphonTYHS+mARsMX12G2REyRFVVbB+vT6ugD4X39Zx1oEC/hsYBcFpUEshFCVHzJ0Ls2ZBSoruy/n5wB7DqQBOArvQ3ymLTTvHwc4mckRlJSwzOWLlSpgwAXgYuGraugsYjz7fD0KwRscsNUqOGDBAH5dQSOdiAJ4ChgHpJv7JQDEEiaCOQXIzOSIrC4qKIDkZOK73w4wjeDe6D8828c+BDVFyREkJXLkCuSZH5OWhz/XR6O/xReixxzGgHIKzoObpFNA4R+Tm6hiCbmdVlY4zoPvuVPTY40Xg/2Pv/8Oruu47f/S1ZVGFHwETYlKigBzsluLSS2lVdbgM19Qt0AB9NCp8NebqilJ5FKWyHhiBwQxgLDBSAQe4cFUK0TUlVhSoAtWcO5jGkFAYl9IqJKoTJq5aYIqwg8s8FIvwIwTQun981kEHoSOdc1iSPtLa7+fZD+yz137pvT577c9ZZ/9YqxCCQ2DSoTROjpg5E+7ckTZWVwcMQ/oER4FKG7MFtm3Ms53QLnLEtm0wbpycZyDcqio59xJSTz+v2RPq+Axo7DMLJLG0xewf+/xDKjwfWJq9aWVp9qaVpdmbVpZmb12xoss9MGPGjDHjxo0zn/70p00QBGHMFLI0e9PK0uzNdT1jF2+eAY3qdgrlTewHx1Ln+cByzfOB5ZrnA8s1zweWa55L1oVuWAb4CXD58mVaWlr46U9/ijGGzuRLzLSyXPOudcO61ke+NMdMKysV9fsOaLS7DXInOBlFyz9gnEqd5wNLszetLM3etLI0e9PK0uzt93h4X049WuafgaG97Ms1zweWa970bljTO9upF3xpjplWVkrq+Rvm7hW9Bf8Jcon4JqkPF5Bt928D0xZ5PJ4PLM3etLI0e9PK0uxNK0uzt+fA/CyGZXj0Fvz3wAwNY6aepdmbVpZmb67rGV0SuQXfrzugrhetc6pqZWn2ppWl2ZtWlmZvWlkavX3xqafM90aM6LQDapBO6NowZv2K9bi8ocgPj3s8/AxiMj9IfItZf2GFHdAkl+zskDVQvGllafamlaXZm1aWRm+//du/bX765JPGZHfeAW0D0xLGrF+xHpe3lpjOJzzUNlL5QeJDzPoLy7uXkB5XOTkhqy95PrBc83xgueb5wHLNc8HKyMhgaGurDHPWiQLg80kyB3rMtLMel/dl4ImHYO3/TbPbU9VAjVl/YSWisAMao9mzQ1Zf8nxgueb5wHLN84HlmueCdfHiRa5+6lMyxm4nMsjb8MlooMdMO+txeY/84IhhpfKD5CHUAI1Zf2ElorADGqN790JWX/J8YLnm+cByzfOB5ZrngvXxxx9TEwSYOKw24GtJMgd6zLSzHpf3yA+OGFYqP0geQg3QmPUXViLq11NxhgoVKlSo/qFBgwYxKiODI7du8X9ra3swP7xBOp9NyORNN/vQY6je1Vpksr8nOtl2327b2It+QrlTIlNxhldAY/RgisiQ1Sc8H1iueT6wXPN8YLnmuWDdvXuXf7t5k+avt1EBfIh0Mj5EOhozSL7zOdBjpp31uLztyA+P+8gPEWrl3/vAP9rtfeGrJ1mueVpZiSjsgMaom856yOphng8s1zwfWK55PrBc81yxjDEMGS5XtcYB6fbfjaR25dOHmGlmPS7vJvLDowL5IWKGt/8geZ7Huxo+UGPWX1iJKOyAxui990JWX/J8YLnm+cByzfOB5ZrnA8s1zweWC95N2n+QrHzv8X6QuPTVUyzXPK2shNTTY3b2hHpqHNCJE0PWQPGmlaXZm1aWZm9aWZq9aWVp9qaVpdmbVpZmby5ZA34g+k+QwYuvIlO9pRKk5+z+sdNQpcrzgaXZm1aWZm9aWZq9aWVp9qaVpdmbS9bTYM51YJ2zn4cxC9uZy3pGlwHfAW2lfQaNthQC9lzMvob2acBS4fnA0uxNK0uzN60szd60sjR708rS7M0l62lkVqHOWPdIvhOqtZ5aWZq9ua5n7OJNBzQasKtJBija648yzLTUeT6wNHvTytLsTStLszetLM3etLI0e3PJOt8N63wYs7CdOapn7OLdVJwjUygfxH4wIXWeDyzXPB9Yrnk+sFzzfGC55vnAcs3TyvpiN6wvJsGK/m2N9dTKcs3TykpF6T3M71ntB4YABRBUgcmCyrNQXQ27d0uRmhoYNAgWL5b1oiJ49VWYMAE4h7xut8/yxgAfAyV2gORS2FACkyfDpUuwYgUcOCBF6+vh8mVYutTuWw4sROayvQKMBnJlUxAB0wyRlbK+ahXMnQvTp8P161BYCIcOQXo6vPsu0Ai8ZrkVwH+1rDsQ5IOpg8gwOHkSjh6FykopumkTTJoE8+bJem4usBcYBZwGDgKVlrUNgnFgFkAEyM+H7dshMxOamuCttySOALt2wYgRUFBgPRUC64HxwETgMFBjY7ZX8EVFUrS4GJYtg4kT4cIFeP31mLHG6oBWoNSuD0ZegZwCwUdgyiFSL5sOHoSWFmEBLF8OCxbA1Klw9SpQhFQE66cwJv5rwMyCyPNw44bUo74eMjLg2DE4dQoqKqTsG2/YYzgbmZVjvq1rLvAeBO+A2SR/assWaUe59u/k5cGePTB6NDQ2wv79ElMAdiDtK9/y9wNvQjAWzPuQuUfiDMIYMkTaBUjbXbsWnn0WaAY22+OKZV4Bim38vwKVZdIOLl6E1auhrk6K7t8vsSors/suARYB2cBlZN67aMwawJyHyCuyvnKl1HPaNLh2TTw1NEBaGhw5ggzmt8Zy1yHnQy5wG4IXwRyAyGA4fhxOnIANG6RoZSVMmQJz5kBbm8Rw3z4k852yx3SLjdm/AM9AkCc/sdPnSxsdMwbOnIG334adO4VbXQ2jRsHChdZTAVAFZAG/Avw1sNvGrAby4uSIc+dg40brCaAWuAWU2PVPAU8DkyG4BGYFROLkiPJy8ZOTA1euWEaD5USAP46J/yowcyESJ0c0NsJrNkdUVMhxYSZwB2ljdcALwJPAUQgqJWZTO8kRe/dKrE6flvNs61braRtyPi6w8a8DtkOQCaYJxnaRIwoLYf16GD8e+MCyaiz3FwF7zgaAKYZNcXJEXR20tkJpNEeUAS8BU4CPgLExMTsIpgUicXJEURFEbI44fBjOngVWWe4aYBawAvhd5DulHkwGlHWSI3JyZNrCe/dg/nzrdzjwHvAOsMnGrBmYAEGuxD+tixyxY4e05fx86+lF4E1bx18B3gV22ZjtgQVxckRzM2zeLMcVkO+3u0CxXf8U8AwwCYKLYFZDJE6OWLIEFi2C7Gxpy2VlwCHLaQDO0/6dstLWcxrs6yRHNDXBGpsj1q2DGTOQNnrb1vUAMvbSp4ETEGyQmOXEyREjR8pxiUQkFwPwVVu3PBv/t4FqCMaAOQNZXeSIggKoqoKsLOCs7IftR/A54Bqw2Ma/CLbEyRG1tXDrFpTYHFFaipzrk4FLto1FY1YPwWUwSyUFdMwRJSUSQ5B6NjdLnAFpu3OB5cDvAIUQHAKTDqVxcsTMmXDnjrSxujpgGHASOGo95SDn6yQI5kn86SJHbNsG48bJeQbCraqScy8h9cIdc+fq7BZ89JIxSSxtHfaPPv+QCs8HlmZvWlmavWllafamlaXZm1aWZm9aWZq9aWVp9ua6nrFLIrfg+/VUnK3Ij06QGreR3CXde3SYAizNQlLg+cDS7E0rS7M3rSzN3rSyNHvTytLszSXrbseyHVj3gUEJslx784Gl2ZvresbKu6k4d6VQ/qHe957UeT6wXPN8YLnm+cByzfOB5ZrnA8s1TytrZzesnUmwon9bYz21slzztLJSUo/fL+8Bxd6Cb7PLWTBDk7xEPNTuF2WYSOo8H1iavWllafamlaXZm1aWZm9aWZq9uWb9MA7rh2HMwnbmsJ6xy4AfhunfwbSAWfsYgRpq928Bc3/N4/F8YGn2ppWl2ZtWlmZvWlmavWllafamlaXZm1aWZm+u6xldBnwH1PUyfnzIGijetLI0e9PK0uxNK0uzN60szd60sjR708rS7M0lK+yAJrlEIiFroHjTytLsTStLszetLM3etLI0e9PK0uxNK0uzN5cs7waiDxUqVKhQoUIlpqHAWqAFeSO6xa4P7UtTofxRL1ywdK6eugL6wgsha6B408rS7E0rS7M3rSzN3rSyNHvrCdZQMN9D5oM3Mcs9+3mizwBqr6c2lmZvLlnhFdAkNWZMyOpLng8s1zwfWK55PrBc83xgueZpZ5UjE0o90WH7E/bz8iR5LuQDyzVPKysRhR3QGD2YAi1k9QnPB5Zrng8s1zwfWK55PrBc87Szvsyjnc+o0uz2ZHgu5APLNU8rKxGFHdBQoUKFChXKM32+i21BN9tDhXKhfj0Vp2sNHgy3b4esvuL5wHLN84HlmucDyzXPB5ZrnnZWCzA2ThkDfAiM6yNvA5nlmqeV5d1UnI+rN98MWX3J84HlmucDyzXPB5Zrng8s1zztrK8h88B3pja7PRmeC/nAcs3TykpEYQc0RmPj/RwMWb3C84HlmucDyzXPB5Zrng8s1zztrO1AE9IJjd4GNXa9yW7vK28DmeWap5WViPp1B/QT5JfaTSA7RUa23b8N+IP3H4/nA0uzN60szd60sjR708rS7E0rS7O3nmZdAZYBFcjt9vv23wpghi3fV94GGkuzt+eAqx1YV+3nPa4eH7SzBxQdB7QVGbeszS7ZSY5TlR2zrwFjMlPn+cDS7E0rS7M3rSzN3rSyNHvTytLsTStLszetLM3enuuG9VyS9YxdBvxUnNEOaDRgN5MM0M3YwIMxkdR5PrA0e9PK0uxNK0uzN60szd60sjR708rS7E0rS7O3q92wriZZz9jFu4HoB6dQPnDE84HlmucDyzXPB5Zrng8s1zwfWK55PrBc83xguea5ZI3shjUyCVYqSu9hfs9qPzAEKICgCkwWVJ6F6mrYvVuK1NTAoEGweLGsFxXBq6/ChAnAOWAjsM/y/hcwByiRg2JKYUMJTJ4Mly7BihVw4IAUra+Hy5dh6VK7bzmwEMhBHq6pASKyKYiAaYbISllftQrmzoXp0+H6dSgshEOHID0d3n0XaARes9wK4CeWdQeCfDB1EBkGJ0/C0aNQWSlFN22CSZNg3jxZz80F9gKjgNPAQeBzlrUNgnFgFshqfj5s3w6ZmdDUBG+9JXEE2LULRoyAggLrqRBYD4wHfg6MlvoGgNkLuTbOAMXFsGwZTJwIFy7A669Dba3l1AGtQKld/ytb3ykQfASmHCL1sungQWhpERbA8uWwYAFMnQpXrwJF7fHmMPA/Y+K/BswsiDwPN25IPerrISMDjh2DU6egokLKvvGGPYazkcmR5wOftqz3IHgHzCZZ3bJF2lFuruyblwd79sDo0dDYCPv3S0wB2AGMAfLtMRgMvAnBWDDvQ+YeiTMIY8gQaRcgbXftWnj2WaAZ2GyPK8CPgHlAsY3/V6CyTNrBxYuwejXU1UnR/fslVmVldt8lwCLkwaHLwP83JmYNYM5D5BVZX7lS6jltGly7Jp4aGiAtDY4cQd5aWGO564CPLes2BC+COQCRwXD8OJw4ARs2SNHKSpgyBebMgbY2ieG+fUjmO2UZW2zMpgPPQJAnP7HT50sbHTMGzpyBt9+GnTuFW10No0bBwoXWUwFQBWSJJ8YAu23MaiAvTo44dw42brSeAGqBW0CJXT8IbAAmQ3AJzAqIxMkR5eXiJycHrlyxjAbLse3rQfxXgZkLkTg5orERXrM5oqJCjgszgTtIG6tDzstlwFEIKiVmUzvJEXv3SqxOn5bzbOtW62kbMg7PAsvKALZDkAmmCcZ2kSMKC2H9ehg/HvjAsmos931skrDxL4ZNcXJEXR20tkJpNEeUAS8hU/V8hJwH0ZgdBNMCkTg5oqgIIrbs4cNw9iywynLXALNsPeuQ75R6MBlQ1kmOyMmB2bPh3j2YP9/6HW6P4TvAJsuaBkyAIFfin9ZFjtixQ9ryg8HAXwTeRMZKuglkArtszPbAgjg5orkZNm+W4wrI99tdoNiufwuoBCZBcBHMaojEyRFLlsCiRZCdLW25rAw4ZDkNwHlbzwiw0tZzGuzrJEc0NcEamyPWrYMZM4AXkPPxReCAZS0FTkCwQWKWEydHjBwpxyUSkVwMwFeBZ4A8y0oHqiEYA+YMZHWRIwoKoKoKsrKAs7Ifth9Bk2UutvEvgi1xckRtLdy6BSU2R5SWIuf6ZOASsCImZvUQXAazVFY75oiSEokhSD2bmyXOgLTduZZVCxRCcAhMOpTGyREzZ8KdO9LG6uqAYcBJ4KhtE6OBqbZtzJP400WO2LYNxo2T8wyEW1Ul515C6oU75s4V7xZ8W5KXiB+69AzGLEid5wNLszetLM3etLI0e9PK0uxNK0uzN60szd60sjR7c13P2MW7W/DJjp96G4nUAxWmzvOB5ZrnA8s1zweWa54PLNc8H1iueT6wXPN8YLnmuWRd64Z1LQlWKur3HdBodxvg+ST3jZaPZaTK84Gl2ZtWlmZvWlmavWllafamlaXZm1aWZm9aWZq9Te+GNf2RPURDgbXIbFr37L9r7edJqRfumDtX9Bb8J7S/9ZXssAjRJZv2t8raRj4ezweWZm9aWZq9aWVp9qaVpdmbVpZmb1pZmr1pZWn29hztb8NHWVeJPwTTUDDfA3OPh2/f37OfD7HlBvwwTK6XrVtD1kDxppWl2ZtWlmZvWlmavWllafamlaXZm1aWZm+JsNbyaOczutwDs8KW8+4Z0MfVs8+GrL7k+cByzfOB5ZrnA8s1zweWa54PLNc8H1iueb3N+jLwRJxtacDiJP5e2AGNUXNzyOpLng8s1zwfWK55PrBc83xgueb5wHLN84HlmtfbrM93sS1ARrhLWL1wx9y5euoW/KhRIWugeNPK0uxNK0uzN60szd60sjR708rS7E0rS7O3RFgtdH773SDPj/4vWy58BjTJJRIJWQPFm1aWZm9aWZq9aWVp9qaVpdmbVpZmb1pZmr0lwuruGdBXg8BA+AxoqFChQoUKFSpUKEfajkwMdR/pkWL/bQP+6VOf4tvjxyfMCjugMXow3V7I6hOeDyzXPB9Yrnk+sFzzfGC55vnAcs3zgeWa19usm8AMZNbsD5GO6IfAtuHDKZ8yhWG/+IsJ/73+PRe8Y929G7L6kucDyzXPB5Zrng8s1zwfWK55PrBc83xgueb1BesmsNEuUY184glG/Z//gzEmzl6dqOef2HSv8BlQHSzN3rSyNHvTytLsTStLszetLM3etLI0e9PK0uztcVhBEJgnnnjCpKWlGUjsGdDwCmioUKFChQoVKlSolGWM4f79+0nv1O/UY1NxjnE4PZYi1tNgzndg3QWzFZlWa6DUUytLszetLM3etLI0e9PK0uztoSkSx3Q/RWIYM70szd5c1zO6DPhhmFppH3uqLYWAZcfsa8CYytR5WllPI0MjdGRFeT8kuU6o1npqZWn2ppWl2ZtWlmZvWlmavT3XDSuZTqgvMdPK0uzNdT1jF286oNGA3UwyQNFef5RhIqnztLLOdcGK8tYOgHpqZWn2ppWl2ZtWlmZvWlmavV3thnU1jFm/YWn25rqesYt344AOTqF8EPvBxdR5Wlnju2GBzO2aqLTWUyvLNc8HlmueDyzXPB9YrnkuWSO7YY3sI1+ueT6wXPO0slJR/34JaT8wBCiAoApMFlSehepq2L1bitTUwKBBsHixrBcVwauvwoQJwDlkHIF9lvctYA5QIgfFlMKGEpg8GS5dghUr4MABKVpfD5cvw9Kldt9yYCGQA1wBlgMR2RREwDRDZKWsr1oFc+fC9Olw/ToUFsKhQ5CeDu++CzQCr1luBdIoIsAdCPLB1EFkGJw8CUePQmWlFN20CSZNgnnzZD03F9gLjAJOAweBZyxrGzAOggXwBeAz+fDX2+HXMiGjCT5+C65Xw3ng/7MLRoyAggLrqRBYj/RuzwOjgRobs72Qa+MMUFwMy5bBxIlw4QK8/jrU1lpOHdAKlNr1V219p0DwEZhyiNTLpoMHoaVFWADLl8OCBTB1Kly9ChS1x5vD9v/R+K8BMwsiz8ONG1KP+nrIyIBjx+DUKaiokLJvvGGP4WzgHjAfeMqy3oPgHTCbZHXLFmlHubmyb14e7NkDo0dDYyPs3w/bt1tPO5BJcvORs24w8CYEY8G8D5l7YNcuKbpnDwwZIu0CpO2uXQvPPgs0A5vtcQX4S2AeUGzj/xWoLJN2cPEirF4NdXVSdP9+iVVZmd13CbAIyAYuA6tiYtYA5jxEXpH1lSulntOmwbVr4qmhAdLS4MgRZGTiNZa7DhkYLgLchuBFMAcgMhiOH4cTJ2DDBilaWQlTpsCcOdDWJjHctw/5hj1lGVtszKYDz0CQJz+x0+fLuT5mDJw5A2+/DTt3Cre6GkaNgoULracCoArIAv7ZHovdNmY1kBcnR5w7Bxs3xoyPVwvcAkrs+gpgAzAZgktgVkAkTo4oLxc/OTlw5YplNFhOBPgfMfFfBWYuROLkiMZGeM3miIoKOS7MBO4gbawOeBJYBhyFoFJiNrWTHLF3r8Tq9Gk5z7ZutZ5sjmAB8ASQAWyHIBNME4x9S+IM0nZjc0RhIaxfD+PHAx9YVo3lfhObJGz8i2FTnBxRVwetrVAazRFlwEvAFOAjJE9GY3YQTAtE4uSIoiKI2LKHD8PZs0ibB2m7s5CcVod8p9SDyYCyTnJETg7Mng337sH8+dbvcOA94B1gk43ZNGACBLkS/7QucsSOHdKW8/OtpxeBN4GxNoaZwC4bsz2wIE6OaG6GzZvluALy/XYXKLbry4FKYBIEF8GshkicHLFkCSxaBNnZ0pbLyoBDltOA5P/x9histPWcBvs6yRFNTbDG5oh162DGDOAF4Lat6wFgGLAUOAHBBolZTpwcMXKkHJdIRHIxAF9FvuPybPzTgWoIxoA5A1ld5IiCAqiqgqws4Kzsh+1H8A3LXGzjXwRb4uSI2lq4dQtKbI4oLUXO9cnAJSRnRGNWD8FlMEtltWOOKCmRGILUs7lZ4gxI251rWbVAIQSHwKRDaZwcMXMm3Lkjbayuzsb7JHDUtokngKm2bcyT+NNFjti2DcaNk/MMhFtVJedeQuqFO+bOFe8WfFuSl4gfuvTcyeXnZHj9kRXlfSjn5iPTa90D8z0efka0P9azL1mavWllafamlaXZm1aWZm9aWZq9aWVp9ua6nrGLd7fgb6dQ3jjiaWVd6IYF8E/AryM/fmL1BHKhobyHvPnAcs3zgeWa5wPLNc8HlmueS9a1bljXkmD5EjOtLNc8raxU1O87oNHuNsDzSe4bLf+AsT91nlbW7yFztMayYtlngQk82vmMKo2HnxHVWk+tLM3etLI0e9PK0uxNK0uzt+ndsKZ3tlMv+HLN84Gl2ZvreiatXrhj7lw9Ng7ozMfjaWU9Tcw4oJYVOw5ox1vvHZd7/aSeWlmavWllafamlaXZm1aWZm8PjQNqWU7GAR3AMdPK0uzNdT2jy4Afhsn1omVKq95mtRC/89lmtw+EempgafamlaXZm1aWZm9aWZq9aWVp9qaVpdmbS5Z3z4CGSk1fA+JNoNVmt4cKFSpUqFChQjlTL1ywdK6eugKaleUnayjytnvsjEltdP4WfH+upwaWZm9aWZq9aWVp9qaVpdlbR9ZQMK+BuYTk6RZkQpFEZrXzNWZaWJq9uWSFV0CT1KJFfrJuAjOQITg/RK6GfmjXZ9jtfeVtoLFc83xgueb5wHLN84HlmtdTrKHACeB1ZAznJ5ChQivs50N70Zdrng8s1zytrEQUdkBjlJ3tL+smMib/OGTs3nF2vavOZ295G0gs1zwfWK55PrBc83xgueb1FKscGR4vkWHzetqXa54PLNc8raxElHQH9H/+z//JH/zBH/D5z3+eIAj47//9vz+0ffHixQRB8NDy+7//+w+V+fd//3cKCgoYPnw4Tz75JC+99BI3btx4rIq40OXLIasveT6wXPN8YLnm+cByzfOB5ZrXU6wvk/iwed2xXKg/xEwTyzVPKysRBcYYk8wOf/3Xf82pU6f4zd/8Tf7wD/+QhoYG/tN/+k8Pti9evJh/+7d/4y/+4i8efJaRkcHIke2z137pS1/i8uXL7Nmzh7t37/LHf/zH/NZv/Rbf/OY3E/Jw/fp1RowYkYzthJSeLlOrhay+4fnAcs3zgeWa5wPLNc8HlmteT7HuEb8DCvIIVXov+XLN84HlmqeV1drayvDhw7su9DgvAwGmoaHhoc/+6I/+yOTm5sbd58c//rEBzPe+970Hn/31X/+1CYLAfPTRRwn93XAYJh0szd60sjR708rS7E0rS7M3rSzN3mJZjzNsnq8x08TS7G1ADMN04sQJRo8ezYQJE/iTP/kTrl69+mDb6dOnefLJJ8mOedjg937v90hLS+Mf/uEfOuXduXOH69evP7SEChUqVKhQvikcNi/UQJHzDujv//7v8/bbb/Pd736XzZs3c/LkSb70pS9x/76cMh9//DGjR49+aJ/09HQ+85nP8PHHH3fK/NM//VNGjBjxYBk7dqxr2wA0NISsvuT5wHLN84HlmucDyzXPB5ZrXk+xtgNNSCfU2M+MXW+y23vLl2ueDyzXPK2shJTQPe84gkdvwXfU+fPnDWC+853vGGOMqaysNL/8y7/8SLmnnnrK7Nq1q1PGz372M9Pa2vpguXTpkoHHn4pzKJivgvm55bRNl38vINNXJst7aEqr6Q6nx1LE0uxNK0uzN60szd60sjR708rS7K0r1lBk3M8WEhsHNIxZ2M56q57Rpcen4oTuO6DGGPPZz37W7N692xhjzFtvvWWefPLJh7bfvXvXPPHEE+av/uqvEvq70WdAW2l/7qUtyYANBfM+7QOvGzAm8vAg7E8neRDbYnmR1L1pZWn2ppWl2ZtWlmZvWlmavWllafamlaXZm1aWZm+u6xm7qBiI/sMPP+Tq1auMGTMGgKlTp/LJJ5/w/e9//0GZ48eP09bWxm//9m+n9DcC++/JJPYpBybF7NuRlwZ8Jwle9G935KXiTSvLNc8HlmueDyzXPB9Yrnk+sFzzfGC55vnAcs3TykpJCV1yjNFPf/pT09TUZJqamgxgtm3bZpqamszFixfNT3/6U/PKK6+Y06dPm//9v/+3+c53vmN+4zd+w/zSL/2S+dnPfvaA8fu///tmypQp5h/+4R/M3/7t35pf+qVfMgsXLkzYQ8croLE9dhJcOn2TcELqvDYPWJq9aWVp9qaVpdmbVpZmb1pZmr1pZWn2ppWl2ZvresYuiVwBTSdJnTlzht/5nd95sL5s2TIA/uiP/og///M/54c//CFf//rX+eSTT/j85z/PrFmzeOONN8jIyHiwT11dHWVlZfzu7/4uaWlpzJ8/n507dyZrBfYDQ4ACCKrAZEHlWaiuht27pUhNDQwaBIsXy3pREbz6KnxhAnAOme5nn+Vdt8wS+QVgSmFDCUyeDJcuwYoVcOCAFK2vl0Fbly61+5YDC4Ec4Ipl/99lUxAB0wyRlbK+ahXMnQvTp8P161BYCIcOyRhc774LNAKvWW4FMudaANyBIB9MHUSGwcmTcPQoVFZK0U2bYNIkmDdP1nNzgb3AKOA0cBD4K+ttGwTjwCyACJCfD9u3Q2YmNDXBW29JHAF27YIRI6CgwHoqBNYD44HhwH8GamzM9kKujTNAcTEsWwYTJ8KFC/D661Bbazl1QCtQatf/F/BzYAoEH4Eph0i9bDp4EFpahAWwfDksWABTp8LVq0ARUhGAw8CvI/PUAcEaMLMg8jzcuCH1qK+HjAw4dgxOnYKKCin7xhv2GM5GBtybD3wTmZv0PQjeAbNJ/tSWLTBhgo0zkJcHe/bA6NHQ2Aj790tMAdgBjAHygWeBbOBNCMaCeR8y90icQRhDhki7AGm7a9fCs88CzcBme1wBPgG+BRTb+H8FKsukHVy8CKtXQ12dFN2/X2JVVmb3XQIssl4uA/8KTLUxawBzHiKvyPrKlVLPadPg2jXx1NAAaWlw5Ajy9sMay10HvIGkodsQvAjmAEQGw/HjcOIEbNggRSsrYcoUmDMH2tokhvv2ASOBU/aYbrEx+wrwDAR5gk6fL210zBg4cwbefhuiaaS6GkaNgoULracCoArIAoYB/y9gt41ZDeR1kiMmTIBz52DjRusJoBa4BZTY9bPI2x+TIbgEZgVE4uSI8nLxk5MDV65YRoPlROxxyLTxXwVmLkTi5IjGRnjN5oiKCjkuzATuIG2sDjkH3gKOQlApMZvaSY7Yu1didfq0nGdbt1pP25Ap0RbY+P8GsB2CTDBNMLaLHFFYCOvXw/jxwAeWVWO512y9i2z8i2FTnBxRVwetrVAazRFlwEvIlD8fIeelvXEWHATTApE4OaKoCCI2Rxw+DGfPAqssdw0wy7L/EflOqQeTAWWd5IicHJg9W8ZMnD/f+h0OvAe8A2yyMfsyMAGCXIl/Whc5YscOacv5+dbTi8CbyDybQ4E/AnbZmO2BBXFyRHMzbN4sxxWQ77e7QLFd/xECmQTBRTCrIRInRyxZItMzZmdLWy4rAw5ZTgNwHtiNfKestPWcBvs6yRFNTbDG5oh162DGDOAF4Lat6wHg15DX+E9AsEFilhMnR4wcKcclEpFcDMBXgWeAPBv/yUA1BGPAnIGsLnJEQQFUVUFWFnJeV9u6Afw78P8DFtv4F8GWODmithZu3YISmyNKS5FzfTJwCVhB+/dwPQSXwSyVFNAxR5SUtL8YFInIscX2I1gFzAX+GPgBUAjBITDpUBonR8ycCXfuSBurq0Ny4UngKFBpY/ZfbNuYJ/GnixyxbRuMGyfnGQi3qkrOvYSU7BVQDeqxK6ARh78kBiBLszetLM3etLI0e9PK0uxNK0uzN60szd60sjR7c13P2EXFM6C9qdtJlP0aMmbaQ7r28OqFJP+26YKVjDetLNc8H1iueT6wXPN8YLnm+cByzfOB5ZrnA8s1TysrJfXCBUvnir0C2hazpPoWfOyvgOj647wF39aBlaw3rSzN3rSyNHvTytLsTStLszetLM3etLI0e9PK0uzNdT1jlx4fhqmvFO2AfmKD5Gwc0Ab59wIOxgFteDxvWlmavWllafamlaXZm1aWZm9aWZq9aWVp9qaVpdmb63pGlwHfAXW9aJ1TVStLszetLM3etLI0e9PK0uxNK0uzN60szd60sjR7GxBzwfdXHTkSsvqS5wPLNc8HlmueDyzXPB9Yrnk+sFzzfGC55mllJaKwAxqjpqaQ1Zc8H1iueT6wXPN8YLnm+cByzfOB5ZrnA8s1TysrIfXCHXPnCm/B62Bp9qaVpdmbVpZmb1pZmr1pZWn2ppWl2ZtWlmZv4S34UKFChQoVKlSoUANbvXDB0rl66gro5Mkha6B408rS7E0rS7M3rSzN3rSyNHvTytLsTStLszeXrPAKaJKaMaP9/0OBtUALMiNji10fmgLLpS9NLNc8H1iueT6wXPN8YLnm+cByzfOB5ZrnA8s1TysrEYUd0Bi98IL8OxQ4gUzDPhZ4wv5bYT9PpBMaZbn0pY3lmucDyzXPB5Zrng8s1zwfWK55PrBc83xgueZpZSWisAMao9t23qlyYArS8YzVE/bz8iRYLn1pY7nm+cByzfOB5ZrnA8s1zweWa54PLNc8H1iueVpZiSgwxpje/ZOPr+vXrzNixIge47cgVzw7kwE+BMb12F8PFSpUqFChQoXqv2ptbWX48OFdlunXV0A/AdqAq8BzKTKes/u3AW0H5N/MLsoHwOeTYKXqTStLszetLM3etLI0e9PKAngaONeBd85+3pfeXLKexl0dXfO0xiw8N/uWpdmb63ompR5/Zb0HFH0LvhWMwc5hCua5JN/Sei5mXwPGRNp5Js7SBqYlSVay3rSyNHvTytLsTStLszetLMA8DeZeHN49u72/17OrOt4PY9Yr7UyrN60szd5c1zN28eYt+MD++16S+0XLR/fnePu6ibNPG/C1JFnJetPK0uxNK0uzN60szd60sgC+i9zS6oyXZrf3hTeXrO8Qv44B8H0SH6kkuntXMTueBEtrzMJzs29Zmr25rmfS6oULls7V8QpobI+dJJa2mP0NGDP5UV5bzPo9MN8DMzRFlktffcHS7E0rS7M3rSzN3rSyNHvrLVaUt1aht4HC0uxNK0uzN9f1jF0SuQKaTn/WfmAIUABBFZgsqDwL1dWwe7cUqamBQYNg8WJZLyqCV1+FCROQB302Avssbwwy1lKJvQpaCtdLYPhkuHEJtq+A3zwA3wTq6+HyZVi61O5bDiwEcoArwOh2m0EETDNEVsr6qlUwdy5Mnw7Xr0NhIRw6BOnp8O67QCPwmt25Avg68L+BOxDkg6mDyDA4eRKOHoXKSim6aRNMmgTz5sl6bi6wFxgFnAYOAt+2/G0QjAOzACJAfj5s3w6ZmTIf7FtvSRwBdu2CESOgoMB6KgTWA+OBicB/BGpszPZCro0zQHExLFsGEyfChQvw+utQW2s5dUArUGrXBwN/B0yB4CMw5RCpl00HD0JLi7AAli+HBQtg6lS4ehUoQioCcNh6vGbjvwbMLIg8DzduSD3q6yEjA44dg1OnoKJCyr7xhj2Gs5EBYOdb3g+A9yB4B8wm+VNbtkg7ys2VffPyYM8eGD0aGhth/36JKQA7kPaVb/njgTchGAvmfcjcI3EGYQwZIu0CpO2uXQvPPgs0A5vtccUyNwDFNv5fgcoyaQcXL8Lq1VBXJ0X375dYlZXZfZcAi4Bs4DLycLOxMWsAcx4ir8j6ypVSz2nT4No18dTQAGlpcOQI0ASssdx1wDeAC8BtCF4EcwAig+H4cThxAjZskKKVlTBlCsyZA21tEsN9+4CRwCl7TLfYmOUDz0CQJzbT50sbHTMGzpyBt9+GnTuFW10No0bBwoXWUwFQBWQBvwLMAHbbmNVAXpwcce4cbNxoPQHUAreAErv+KeAfgMkQXAKzAiIHZFPHHFFeLn5ycuDKFctosJwI8MfAv9v4rwIzFyJxckRjI7xmc0RFhRwXZgJ3bJzqgBeAN4GjEFRKzKZ2kiP27pVYnT4t59nWrdbTNuRtywU2/k8D2yHIBNMEY7vIEYWFsH49jB8PfGBZNZb7i/ZYFNn4F8OmODmirg5aW6E0miPKgJeQ4Ug+Qt4WbbPbDgItsHoZ/BaP5oiiIojYHHH4MJw9C6yy+64BZgErkKtABRDUg8mAsk5yRE4OzJ4N9+7B/PnW73DkktE7wCYbswXABAhyJf5pXeSIHTukLefnW08v2uM3FmmzLwC7bMz2wII4OaK5GTZvluMKyPfbXaDYrn8KOANMguAimNUQiZMjliyBRYsgO1vaclkZcMhyGoDzQD3ynbLS1nMa7OskRzQ1wRqbI9ats2NOvgDctnU9ADxvY3cCgg0Ss5w4OWLkSDkukYjkYgC+CjwD5Nn4jwWqIRgD5gxkdZEjCgqgqgqysoCzsh+2H8HnkLy72Ma/CLbEyRG1tXDrFpTYHFFaipzrk4FLto1Fv4frIbgMZqmkgI45oqREYghSz+ZmiTMgbXcusBy5NVAIwSEw6VAaJ0fMnAl37kgbq6sDhgEngaNApY3ZH9q2Mc9+HXSRI7Ztg3Hj5DwD4VZVybmXkHrhgqVzdXYFNNpj53F6/5HUeT6wNHvTytLsTStLszetLM3eepNlkDtVGr0NBJZmb1pZmr25rmfsksgVUHqhv+hc8W7BJ5N4sOUfCn5O6jwfWJq9aWVp9qaVpdmbVhZg7nbDuzsA6nmODl+aOQ+z2+j8JdF4y8+78fbzARCz8NwMY9Zb9YxdvHkJKapdKZQ3sR9MSZ3nA8s1zweWa54PLNc8H1gAO7vh7UyCpbWev0f7N1xnrDY6f0k0nnyIWXhu9i3LNU8rKyX1wgVL54q9Ahp9UPYsnb8c1NUy1O4XZZhI6jwfWJq9aWVp9qaVpdmbVlaU98M4vB8OoHo+B+Z2lNdh2KR4L4l25e19ZAinWG/37ecDIWbhuRnGrLfqGbsM+Fvw/47cbln7GIEaavdvAdPW8Hg8H1iavWllafamlaXZm1aWZm89Vc+bDdLx1OLNB5Zmb1pZmr25rmd0SaQDGk7FGSpUqFAeaygyiMeXkYEQLiO3sbcBN/vQl2t1rOdPkHp+zX7W8fPtDKz6hwrVm0pkKs5+fQXU9bJvX8gaKN60sjR708rS7E0rK1HeUOS2dceXETreztZaz0RZXdXzRuzn+zqvf3+pp9Z2FrL6hzeXLO9eQnpcjRwZsvqS5wPLNc8HlmueD6xEeeXIewdPdPj8Cft5eRIsl75cs7qq55DYz0e2fx5b/5701p9Zrnk+sFzztLISUdgBjdGpUyGrL3k+sFzzfGC55vnASpT3ZR7tlEWVZrcnykpUfcHqqp5B7EoML7b+qai/x6wveD6wXPO0shJSL9wxd66eugU/YULIGijetLI0e9PK0uxNKytR3iPjAPLoLWrN9UyU1V09HywTOq9/f6mn1nYWsvqHN5esAf8WvOslEglZA8WbVpZmb1pZmr1pZSXKayF+Z6yN9kHdtdYzUVZX9XxoiXRe//5ST63tLGT1D28uWeEzoKFChQoVKq6+BtyPsy3ZQd01q6t6mjifD6T6hwqlUr1wwdK5euoK6PTpIWugeNPK0uxNK0uzN62sRHmxb4e3EX9Qd631TJTVVT1vBUH7QPTTUx/UXkM9tbazkNU/vLlkhVdAk9Qzz4SsvuT5wHLN84HlmucDK1HeTWAGUAF8iFwl/NCuz6B9HEyt9UyU1VU9nzbmwedtz3Re/5701p9Zrnk+sFzztLISUi9csHSu8BlQHSzN3rSyNHvTytLsTStLszetLM3etLI0e9PK0uwtfAY0CX2CPKdzE8hOkZFt928D/uAxeT6wNHvTytLsTStLszetLM3etLI0e9PK0uxNK0uzN9f1TEq9cMHSuaJXQFtpf5anDUx2kj307Jh9DRiTnjrPB5Zmb1pZmr1pZWn2ppWl2ZtWlmZvWlmavWllafbmup6xy4AfhinaAY0G7GaSAboZG3gwZnfqPB9Ymr1pZWn2ppWl2ZtWlmZvWlmavWllafamlaXZm+t6xi4D/hZ8Rw1OofxDs2CMSZ3nA8s1zweWa54PLNc8H1iueT6wXPN8YLnm+cByzdPKSkXpPczvWe1HJvItgKAKTBZUnoXqati9W4rU1MCgQbB4sawXFcGrr8KECcA5YCOwz/JuA3OAEjkophQ2lMDkyXDpEqxYAQcOSNH6erh8GZYutfuWAwuBHOAK8H0gIpuCCJhmiKyU9VWrYO5cmD4drl+HwkI4dAjS0+Hdd4FG4DXLrUDmkIsAdyDIB1MHkWFw8iQcPQqVlVJ00yaYNAnmzZP13FxgLzAKOA0cBH7ZsrZBMA7MAlnNz4ft2yEzE5qa4K23JI4Au3bBiBFQUGA9FQLrgfHI3MmjgRobs72Qa+MMUFwMy5bBxIlw4QK8/jrU1lpOHdAKlNr1f7H1nQLBR2DKIVIvmw4ehJYWYQEsXw4LFsDUqXD1KlDUHm8OA/8WE/81YGZB5Hm4cUPqUV8PGRlw7JhMP1ZRIWXfeMMew9nAPWA+kGVZ70HwDphNsrpli7Sj3FzZNy8P9uyB0aOhsRH275eYArADObnz7TEYDLwJwVgw70PmHokzCGPIEGkXIG137Vp49lmgGdhsjyvIwzrzgGIb/69AZZm0g4sXYfVqqKuTovv3S6zKyuy+S4BFyMM+l4EfxMSsAcx5iLwi6ytXSj2nTYNr18RTQwOkpcGRI0ATsMZy1wGDLOs2BC+COQCRwXD8OJw4ARs2SNHKSpgyBebMgbY2ieG+fUi7OmUZW2zMpgPPQJAnP7HT50sbHTMGzpyBt9+GnTuFW10No0bBwoXWUwFQZY/lk/ZY7LYxq4G8ODni3DnYuNF6AqgFbgEldv2fgQ3AZAgugVkBkTg5orxc/OTkwJUrltFgOREkb0TjvwrMXIjEyRGNjfCazREVFXJcmAncQdpYnY3ZMuAoBJUSs6md5Ii9eyVWp0/LebZ1q/W0DRgHLLCsDGA7BJlgmmBsFzmisBDWr4fx44EPLKvGcm9gk4SNfzFsipMj6uqgtRVKozmiDHgJmaj9I+AfY2J2EEwLROLkiKIiiNiyhw/D2bPAKstdA8yy9axDvlPqwWRAWSc5IicHZs+Ge/dg/nzrdzjwHvAOsMmypgETIMiV+Kd1kSN27JC2nJ9vPb0IvAmMtexMYJeN2R5YECdHNDfD5s1yXAH5frsLFNv1ZqASmATBRTCrIRInRyxZAosWQXa2tOWyMuCQ5TQA52n/Tllp6zkN9nWSI5qaYI3NEevWwYwZwAvI9+6LwAHLWgqcgGCDxCwnTo4YOVKOSyQiuRiArwLPAHmWlQ5UQzAGzBnI6iJHFBRAVRVkZQFnZT9sP4KfWuZiG/8i2BInR9TWwq1bUGJzRGkpcq5PBi4BK2JiVg/BZTBLZbVjjigpkRiC1LO5WeIMSNuda1m1QCEEh8CkQ2mcHDFzJty5I22srg4YBpwEjto28cvAVNs25kn86SJHbNsG48bJeQbCraqScy8h9cIdc+eKdwu+LclLxA9degZjslLn+cDS7E0rS7M3rSzN3rSyNHvTytLsTStLszetLM3eXNczdvHuFvztFMqb2A92ps7zgeWa5wPLNc8HlmueDyzXPB9Yrnk+sFzzfGC55mllpaJ+3wGNdrcBnk9y32j5WEaqPB9Ymr1pZWn2ppWl2ZtWlmZvWlmavWllafamlaXZm+t6Jq1euGPuXNFb8J/Q/qZWqsMFZNP+JljbzMfj+cDS7E0rS7M3rSzN3rSyNHvTytLsTStLszetLM3eXNczugz4YZhcLy++GLIGijetLM3etLI0e9PK0uxNK0uzN60szd60sjR7c8ny7hnQx9WDN2ZDVp/wfGC55vnAcs3zgeWa5wPLNc8HlmueDyzXPK2sRBR2QEOFChUqVKhQoUL1rnrhjrlz9dQt+GHDQtZA8aaVpdmbVpZmb1pZmr1pZWn2ppWl2ZtWlmZvLlnhLfgkVVUVsvqS5wPLNc8HlmueDyzXPB9Yrnk+sFzzfGC55mllJaKwAxqjrKyQ1Zc8H1iueT6wXPN8YLnm+cByzfOB5ZrnA8s1TysrEYUd0BidPRuy+pLnA8s1zweWa54PLNc8H1iueT6wXPN8YLnmaWUlpF54ZNO5euoZ0DFjQtZA8aaVpdmbVpZmb1pZmr1pZWn2ppWl2ZtWlmZvLlnhOKBJLpFIyBoo3rSyNHvTytLsTStLszetLM3etLI0e9PK0uzNJSt8CSlUqFChQoUKFSqUPvXCBUvn6rGpOOc5nNJqgLI0e9PK0uxNK0uzN60szd60sjR708rS7E0rS7M31/WMLgP+FnwrGBMNXAoBy47Z14AxeanzfGBp9qaVpdmbVpZmb1pZmr1pZWn2ppWl2ZtWlmZvrusZu3jTAY0G7GaSAYr2+qMME0md5wNLszetLM3etLI0e9PK0uxNK0uzN60szd60sjR7c13P2MW7Z0AHp1A+cMTzgeWa5wPLNc8HlmueDyzXPB9Yrnk+sFzzfGC55mllpaL0Hub3rPYDQ4ACCKrAZEHlWaiuht27pUhNDQwaBIsXy3pREbz6KkyYAJwDNgL7LO+/A3OAEjkophQ2lMDkyXDpEqxYAQcOSNH6erh8GZYutfuWAwuBHOAK8F+AiGwKImCaIbJS1letgrlzYfp0uH4dCgvh0CFIT4d33wUagdcstwL4O8u6A0E+mDqIDIOTJ+HoUaislKKbNsGkSTBvnqzn5gJ7gVHAaeAg8AuWtQ2CcWAWyGp+PmzfDpmZ0NQEb70lcQTYtQtGjICCAuupEFgPjAf+FRgN1NiY7YVcG2eA4mJYtgwmToQLF+D116G21nLqgFag1K6/Zus7BYKPwJRDpF42HTwILS3CAli+HBYsgKlT4epVoKg93hwG/jwm/mvAzILI83DjhtSjvh4yMuDYMTh1CioqpOwbb9hjOBu4B8yXuBMB3oPgHTCbZHXLFmlHubmyb14e7NkDo0dDYyPs3y8xBWAHMAbIt8dgMPAmBGPBvA+ZeyTOIIwhQ6RdgLTdtWvh2WeBZmCzPa4Ah4B5QLGN/1egskzawcWLsHo11NVJ0f37JVZlZXbfJcAiIBu4DHw5JmYNYM5D5BVZX7lS6jltGly7Jp4aGiAtDY4cAZqANZa7DvgHy7oNwYtgDkBkMBw/DidOwIYNUrSyEqZMgTlzoK1NYrhvHzASOGUZW2zMpgPPQJAnP7HT50sbHTMGzpyBt9+GnTuFW10No0bBwoXWUwFQBWQB5+2x2G1jVgN5cXLEuXOwcaP1BFAL3AJK7PoaYAMwGYJLYFZAJE6OKC8XPzk5cOWKZTRYTgTYExP/VWDmQiROjmhshNdsjqiokOPCTKSt5iPn1i8Ay4CjEFRKzKZ2kiP27pVYnT4t59nWrdbTNmAcsMCyMoDtEGSCaYKxXeSIwkJYvx7Gjwc+sKway/0WNknY+BfDpjg5oq4OWluhNJojyoCXgCnAR8CfxMTsIJgWiMTJEUVFELFlDx+2Yx6uijmOs2w965DvlHowGVDWSY7IyYHZs+HePZg/3/odDrwHvANssqxpwAQIciX+aV3kiB07pC3n51tPLwJvAmOBfwYygV02ZntgQZwc0dwMmzfLcQXk++0uUGzXVwOVwCQILoJZDZE4OWLJEli0CLKzpS2XlSE5B6Ttnqf9O2Wlrec02NdJjmhqgjU2R6xbBzNmAC8At21dD1jWUuAEBBskZjlxcsTIkXJcIhHJxQB8FXgGyLOsdKAagjFgzkBWFzmioEBmAsrKAs7Kfth+BH9pmYtt/ItgS5wcUVsLt25Bic0RpaXIuT4ZuASsiIlZPQSXwSyV1Y45oqREYghSz+ZmiTMgbXeuZdUChRAcApMOpXFyxMyZcOeOtLG6OmAYcBI4atvELwBTbduYJ/GnixyxbRuMGyfnGQi3qkrOvYTUC3fMnSveLfi2JC8RP3TpGYzZkjrPB5Zmb1pZmr1pZWn2ppWl2ZtWlmZvWlmavWllafbmup6xi3e34G+nUN7EfjAhdZ4PLNc8H1iueT6wXPN8YLnm+cByzfOB5ZrnA8s1TysrFfX7Dmi0uw3wfJL7Rss/YJxLnecDS7M3rSzN3rSyNHvTytLsTStLszetLM3etLI0e3Ndz6TVC3fMnavHxgEd+Xg8H1iavWllafamlaXZm1aWZm9aWZq9aWVp9qaVpdmb63pGlwE/DJPrReuUVlpZmr1pZWn2ppWl2ZtWlmZvWlmavWllafamlaXZWzgVZ6hQoUKFChUqVKgBrbADGqMHwwOFrD7h+cByzfOB5ZrnA8s1zweWa54PLNc8H1iueVpZiSjsgMbo1q2Q1Zc8H1iueT6wXPN8YLnm+cByzfOB5ZrnA8s1TysrIfXCI5vOFT4DqoOl2ZtWlmZvWlmavWllafamlaXZm1aWZm9aWZq9hc+AhgoVKlSoUKFChRrY6oULls7VU1dAMzND1kDxppWl2ZtWlmZvWlmavWllafamlaXZm1aWZm8uWeEV0CQVnbs1ZPUNzweWa54PLNc8H1iueT6wXPN8YLnm+cByzdPKSkRhBzRGkyeHrL7k+cByzfOB5ZrnA8s1zweWa54PLNc8H1iueVpZiSjsgMbo0qWQ1Zc8H1iueT6wXPN8YLnm+cByzfOB5ZrnA8s1TysrIfXCI5vO1WNTcQ52OKXVAGVp9qaVpdnbc2CudmBdtZ+HMetfLM3etLI0e9PK0uzNJetpMOc7sO6C2QpmqC0zFMxaMC1g7oG5BOa1mO39oZ6u20Z0GfBTcbaCMdHApRCw7Jh9DRgTSZ3nA0uzN60szd6e64aVTCfUl5hpZWn2ppWl2ZtWlmZvLllPIx3Kjqwo74dgRoP5ni1nYpZ79vPYTqjWerpuG7GLNy8hBfbfk0nuFy0fdPg8FZ4PLNc8H1iueS5Z73XDeo/E5UvMtLJc83xgueb5wHLN08r6DvJ8YkdWlDcJ+CYwBXiiw/Yn7OflPeRNKysVDYgOaFSDUyj/UODrU+f5wHLN84HlmueSNbIb1sg+8uWa5wPLNc8HlmueDyzXPK2s8d2wAJ7n0c5nVGnAl3vIm1ZWKkrvYX7Paj8wBCiAoApMFlSehepq2L1bitTUwKBBsHixrBcVwauvwoQJwDlgI7DP8pqAOUCJHBRTChtK5M2wS5dgxQo4cECK1tfD5cuwdKndtxxYCOQAV4C/BCKyKYiAaYbISllftQrmzoXp0+H6dSgshEOHID0d3n0XaARes9wK4LeBfOAOBPlg6iAyDE6ehKNHobJSim7aBJMmwbx5sp6bC+wFRgGngYNAqWVtg2AcmAViMz8ftm+HzExoaoK33pI4AuzaBSNGQEGB9VQIrEfO0lvAMaDGxmwv5No4AxQXw7JlMHEiXLgAr78eM99sHdBqPUWPZwUwBYKPwJRDxJ4QBw9CS4uwAJYvhwULYOpUuHoVKGqPN4eBjJj4rwEzCyLPw40bUo/6esjIgGPH4NQpqKiQsm+8YY/hbOAeMB9YbGP2HgTvgNkk6C1bpB3l5sq+eXmwZw+MHg2NjbB/v8QUgB3AGMv5LPBXwJsQjAXzPmTukTiDMIYMkXYB0nbXroVnnwWagc32uAJ8H5gHFNv4fwUqy6QdXLwIq1dDXZ0N736JVVmZ3XcJsAjIBi4Dh2Ji1gDmPERekfWVK6We06bBtWviqaEB0tLgyBHk3FljueuAqbautyF4EcwBiAyG48fhxAnYsEGKVlbClCkwZw60tUkM9+1Der+nrJ8tNmYtwDMQ5Mk9nvT50kbHjIEzZ+Dtt2HnTuFWV8OoUbBwofVUAFQBWcAN4Diw28asBvLi5Ihz52DjRusJoBZp89HhSuqADcBkCC6BWQGRODmivFz85OTAlSuW0WA5EWBYTPxXgZkLkTg5orERXrM5oqJCjgszgTs27nXA08DngKMQVErMpnaSI/bulVidPi3n2dat1tM2YBywwMb/ILAdgkwwTTC2ixxRWAjr18P48cAHllVjuWewScLGvxg2xckRdXXQ2gql0RxRBryEXGL6yMYrGrODYFogEidHFBVBxJY9fBjOngVWWe4aYBZyvs9BvlPqwWRAWSc5IicHZs+Ge/dg/nzrdzhy2+AdYJON2b8CEyDIlfindZEjduyQtpyfbz29CLwJjEXy5Algl43ZHlgQJ0c0N8PmzXJcAfl+uwsU2/VvAJXAJAguglkNkTg5YskSWLQIsrOlLZeVIXkCpO2ep/07ZaWt5zTY10mOaGqCNTZHrFsHM2YALwC3bV0P2Lp+VuoabJCY5cTJESNHynGJRCQXA/BV4Bkgz3L+EqiGYAyYM5DVRY4oKICqKsjKAs7Kfth+BP9gmYtlNSiCJ16VY/tIP6IWglvwhRJpmqWlyLk+GbgErIiJWT0El8EslbIdc0RJicQQpJ7NzRJnQNruXOvr94FCCA6BSYfSODli5ky4c0faWF0dknNOAkdtm/gscMG2jXkSf7rIEdu2wbhxcp6BcKuq5NxLSL3wyKZzdXwGNPaZBZJY2nj42Y2Oz3kkw/OBpdmbVpZmb1pZmr1pZWn2ppWl2ZtWlmZvvcWK8u52LNNhe0s/r2cqbSN28eYZ0Khup1DeOOL5wHLN84HlmueSda0b1rUkWL7ETCvLNc8HlmueDyzXPK2sC92wQC4c3o+zrQ34Woe/rbGerttG0uqFC5bOFXsFtC1meZy3+drAmPGp83xgafamlaXZ23PdsFJ9C34gx0wrS7M3rSzN3rSyNHtzyXqa9rfgoywTs97xLfg22rd39xa8pnq6bhuxy4AfhukTGyRn45mteTyeDyzN3rSyNHt7aBxQy3IyDugAjplWlmZvWlmavWllafbmkvU0MeOAWlZ344C22PVuxwFVVE/XbSO6DPgOqOslEglZA8WbVpZmb1pZmr1pZWn2ppWl2ZtWlmZvWlmavblkefcM6OPqypWQ1Zc8H1iueT6wXPN8YLnm+cByzfOB5ZrnA8s1TysrEQXGGNO7f/Lxdf36dUaMGOGcm5YmwzyErL7h+cByzfOB5ZrnA8s1zweWa54PLNc8H1iueVpZra2tDB8+vOu/5+ZPDQxFx9sKWX3D84HlmucDyzXPB5Zrng8s1zwfWK55PrBc87SyElHYAQ0VKlSoUKFChQrVqwo7oDGKzpIRsvqG5wPLNa83WEOBtchERPfsv2vt573hyzXPB5Zrng8s1zwfWK55PrBc87SyElF67/453WpuDll9yfOB5ZrX06yhyAyAU2if93gsMmNqLjADuNnDvlzzfGC55vnAcs3zgeWa5wPLNU8rKyH1+JhJPaBwGCYdLM3etLI0e+uMtRYZ3850styz28OY6WNp9qaVpdmbVpZmb1pZmr2FwzCFChVKjb5M+5XPjkqz20OFChUqVKik1QsXLJ2rp66ATpwYsgaKN60szd46Y8W7+hld7oUxU8nS7E0rS7M3rSzN3rSyNHtzyRrwV0A/AdqAq8BzKTKes/u3Af9r7uPxfGBp9qaVpdnb08C5Dqxz9nOAn3SxrwEu95Av1zyXrKHABiT/RFmf2M+6ejGrp3255vnA0uxNK0uzN60szd5c1zMp9cIFS+eKXgFtRa7CtNkl2fmrn4vZ14AxkdR5PrA0e9PK0uztaeQKZmese3Z7d8+Arh80yKuYDQXzw05YUd4P6HweaJ/bmVaWZm9aWZq9aWVp9ua6nrHLgL8CGlVg/30vyf2i5aP7cz11ng8szd60sjR7+w7yHGdnrDTg+8DXgCbgPpJVsP/eB86mp7MzLc25L9c8l6y1wKROWFHeZKC8D3y55vnA0uxNK0uzN60szd5c1zNZ9eupOFuB4fazaCWS6VG3ERP4DkqW5wPLNc8Hlmteb7GivO8Dc4GvBAFfeeIJRt+7x/8ZNIiaIGC7MbTev09bW5s3MbsNfKqL7Qb4EBjXy75c83xgueb5wHLN84HlmqeV1VGJTMXZv8cB3Q8MAQogqAKTBZVnoboadu+WIjU1MGgQLF4s60VF8OqrMGEC8rDbRmCf5X0OeZCrRA6KKYUNJTB5Mly6BCtWwIEDUrS+Hi5fhqVL7b7lwEIgB7gCfIYH0Q0iYJohslLWV62CuXNh+nS4fh0KC+HQIUhPh3ffBRqB1yy3AtiLjP59B4J8MHUQGQYnT8LRo1BZKUU3bYJJk2DePFnPzbX7jgJOAweB/wl8D9gGwTgwCyAC5OfD9u2QmQlNTfDWWxJHgF27YMQIKCiwngqB9cB4YALw/wBqbMz2yviQRUVStLgYli2DiRPhwgV4/XWorbWcOqAVKLXrg2zdp0DwEZhyiNTLpoMHoaVFWADLl8OCBTB1Kly9ChQhFQE4DPw/af81twbMLIg8DzduSD3q6yEjA44dg1OnoKJCyr7xhj2Gs5FR1+cDF4F/BN6D4B0wm+RPbdki7Sg3V/bNy4M9e2D0aGhshP37JaYA7ADGAPnAbwHPAG9CMBbM+5C5R+IMwhgyRNoFSNtduxaefRZoBjbb4wowGqgEim38vwKVZdIOLl6E1auhrk6K7t8vsSors/suARYB2cjDnKNpf+W9AYLz8JuvwEngP600tP1fAdOmDeL6vxvaFrXx0cH7fCoNPjmCXCZdY/ddB3zdxu02BC+COQCRwXD8OJw4ARs2SNHKSpgyBebMkTmI8/Jg3z5gJHDKHtMtNmb/WeIW5ElyTJ8vbXTMGDhzBt5+G3buFG51NYwaBQsXWk8FQBWQhbTZ3wF225jVQF6cHHHuHGzcaD0BGbXALaDEcgcBZ5BLn5cgWAFfOCC2O+aI8nLxk5MDV65YRoPlROyxaJXVYBWYuRCJkyMaG+E1myMqKmDaNGAmcMe2sTpbx68CRyGolJhN7SRH7N0rsTp9Ws6zrVutp21IT3qBjf8Xge0QZIJpgrFd5IjCQli/HsaPBz6wrBrLfQppw0U2/sWwKU6OqKuD1lYojeaIMuAlZGDaj5Bzyn5DBgfBtEAkTo4oKmofaPvwYTh7FlhluWuAWcArwN9IewnqwWRAWSc5IicHZs+Ge/dg/nzrdzhyyegdYJON2f8FTIAgV+Kf1kWO2LFD2nJ+vvX0IvAmMvDuLwO/B+yyMdsDC+LkiOZm2LxZjisg3293gWK7no7ks0kQXASzGiJxcsSSJbBoEWRnS1suKwMOWU4DcB74S+Q7ZaWt5zTYd008NTTI/OJHjsj3yhqbI9atgxkzgBeQX3UvAgeQ75LNwAkINkjMcuLkiJEj5bhEIpKLAWnvzwB5Nv7jgGoIxoA5A1ld5IiCAqiqgqws4Kzsh+1H8FnLXmzjXwRb4uSI2lq4dQtKbI4oLUXOdZsjWGHj9j2gHoLLYJZKCuiYI0pK2qfHjETsOJ22H8Eq5OrAMuC7QCEEh8CkQ2mcHDFzJty5I22srg4YhiT4o8j3yG8h33mTIJhnO6Fd5Iht22DcODnPQLhVVXLuJaSefl6zJ9TxGdDo0pbkMwptHfaPfZ4rWZ4PLM3etLI0e+uOFeW12PKDBg0yozIyzA9/4RfM/U7KhTF7OF5hO9PN0uxNK0uzN60szd5c1zN28eYZUJAatyW5zyPl302d5wPLNc8HlmueS9YFu09nrKgC4PP2/3fv3uVP7tzhuZ///JHbMo/cxhmgMeuKFdXXHLB8iVl4bvYvlmueDyzXPK2sVDRgOqAAu1Io/9AXcGPqPB9Yrnk+sFzzXLJ+D0kwD3iNj5YxPDwUU1cD0/sQs/e6YBngBrC9D3y55vnAcs3zgeWa5wPLNU8rKyX1wh1z54q9Bd9ml7MkPvxJdBlq94syTCR1ng8szd60srR7exrM1RiW4eGl43Sb3Q1MP9BjNhrMjTisOzaeYTvrHyzN3rSyNHvTytLszXU9Y5cBfwv+PvLG6Trgt4GbSe5/0+63znLMY/B8YGn2ppWl3du/Is/pf5/2zIH99z7ybtH2mPLdDUx/3ZEvrTG7iby7CO2PHUT//QD4P33kyzXPB5Zmb1pZmr1pZWn25rqeSasXLlg6V09NxTllSsgaKN60srR6Gwrmz6bICzT3kH/X8ugv4K4Gpr8P5i/GjzdPPvnkgI3ZI/WfEv9qcdjO+hdLszetLM3etLI0e3PJGvBXQF1r2rSQ1Zc8H1iuea5YN4EPpsnV0HTk3408+gt4O/EHpv/J5z7H9/7jfyQjI2PAxuyRZ2BjWGl2e6oaqDHrLyzXPB9Yrnk+sFzztLISUdgBjdHMmSGrL3k+sFzzept1E5iBDE/7Ie2Pwfy/R4zgTyZO5Af//M/cunVrwMbs8x0/iGEFnW1PQgM1Zv2F5ZrnA8s1zweWa55WViJK790/p1t37oSsvuT5wHLN6wvWTeTq6MaYz9J++lOeOHUKYwz3798fsDH7CTIueDus/b+Grp+R7U4DNWb9heWa5wPLNc8HlmueVlYi6tdTcYYKFSpUb2otcvW3s6Go7tttGzvZFipUqFA+KZGpOMNb8DGKTlkYsvqG5wPLNc8Hlmve47AeeQa2rv0Z2CYSHwPUta+e5vnAcs3zgeWa5wPLNU8rKxGFHdAYDRsWsvqS5wPLNc8Hlmve47Ciz8BuGTyYK4MGYYbBT4KACvv54wxbMlBj1l9Yrnk+sFzzfGC55mllJaKwAxqjkydDVl/yfGC55vnAcs17XNZN4A3g10eNYv0PhvHML/xCpyMG9LavnuT5wHLN84HlmucDyzVPKysh9fSYnT2hnhoHdNKkkDVQvGllafamlaXZm1aWZm9aWZq9aWVp9qaVpdmbS1Yi44Am1QGtqqoy2dnZZtiwYeapp54yubm55p/+6Z8eKnP79m1TWlpqPvOZz5ihQ4eaP/zDPzQff/zxQ2UuXrxo5syZYwYPHmyeeuop88orr5i7d+8m7KOnOqCRSMgaKN60sjR708rS7E0rS7M3rSzN3rSyNHvTyupJb0ORyTC6m1CkN3w5H4j+5MmTvPzyy/z93/89x44d4+7du8yaNYubN9tvPpWXl/M//sf/4Fvf+hYnT57kJz/5CX/4h3/4YPv9+/eZO3cuP//5z/m7v/s7vv71r7Nv3z7WrVuXjBUAPgHakFtf2UnvLcq2+7cBf/CYPB9Ymr1pZWn25pL1NHC+A+susBUY2sfefGBp9qaVpdmbVpZmb1pZrnnPAVc7sK4C/4CMxDEWGaljrF0/Qfwc7LqeSSnhy46d6MqVKwYwJ0+eNMYY88knn5hBgwaZb33rWw/KfPDBBwYwp0+fNsYYc+TIEZOWlvbQVdE///M/N8OHDzd37txJ6O9Gr4C2IlPgtdklO8keenbMvgaMmZo6zweWZm9aWZq9uWQ9jfzi7siK8n5I4r/CNddTK0uzN60szd60sjR708pyzXuuG5bpZIk3TbDresYuzm/Bd9S//Mu/GMD86Ec/MsYY893vftcA5tq1aw+VGzdunNm2bZsxxpjXXnvNTJ48+aHtFy5cMID5wQ9+kNDf7dgBjQbsZpIButnxgBWnzvOBpdmbVpZmby5Z57pgRXnJzJOutZ5aWZq9aWVp9qaVpdmbVpZr3tUuWPGWNuR2fE/XM3bp0bng29ra+K//9b8ybdo0Jk2aBMDHH3/ML/zCL/Dkk08+VPZzn/scH3/88YMyn/vc5x7ZHt3Wme7cucP169cfWjrT4CTrMBiZPu+B5qXO84HlmucDyzVPK2t8NyxIbp50rfXUynLN84HlmucDyzXPB5Zr3shuWJ0p3jTBruuZrFKeivPll1/m7Nmz/O3f/q1LP53qT//0T1m/fv2jG/YDQ4ACCKrAZEHlWaiuht27pUhNDQwaBIsXy3pREbz6KkyYAJxDpi3ZZ3ljgDlAiRwUUwobSmDyZLh0CVasgAMHpGh9PVy+DEuX2n3LgYVADnDFfhaRf4IImGaIrJT1Vatg7lyYPh2uX4fCQjh0CNLT4d13gUbgNcuoAL5oWXcgyAdTB5FhMmTC0aNQWSlFN22CSZNgnm1EubnAXmAUcBo4aP1FgG0QjAOzQFbz82H7dsjMhKYmeOstiSPArl0wYgQUFFhPhcB6pNcxERgN1NiY7YVcG2eA4mJYtgwmToQLF+D116G21nLqgFag1K4PtvWdAsFHYMohUi+bDh6ElhZhASxfDgsWwNSpcPUqUNQebw4jZ2k0/mvAzILI83DjhtSjvh4yMuDYMTh1CioqpOwbb9gYzQbuAfOB37Cs9yB4B8wmWd2yRdpRbq7sm5cHe/bA6NHQ2Aj790tMAdiBtK98yx8MvAnBWDDvQ+YeiTMIY8gQaRcgbXftWnj2WaAZ2GyPK5Y5Dyi28f8KVJZJO7h4EVavbh9ceP9+iVVZmd13CbAIedjnMgKIxqwBzHmIvCLrK1dKPadNg2vXxFNDA6SlwZEjyCjsayx3nW0bEeA28CIEB+ALg2HpcThxAjZskKKVlTBlCsyZA21tEsN9++zxO2UZW2zMpgPPQJAnP7HT50sbHTMGzpyBt9+GnTuFW10No0bBwoXWUwFQBWQBv2LjttvGrAby4uSIc+dg40brCaAWuAWU2PVPARuAyRBcArMCInFyRHm5+MnJgStXLKPBciLAZ2LivwrMXIjEyRGNjfCazREVFXJcmIlMDZqPnFs5wDLgKASVErOpneSIvXslVqdPy3m2dav1tA0YByywrAxgOwSZYJpgbBc5orAQ1q+H8eOBDyyrxnJ/EZskbPyLYVOcHFFXB62tUBrNEWXAS8AU4CNkIMFozA7KZZ5InBxRVAQRW/bwYTh7FlhluWuAWbaedch3Sj2YDCjrJEfk5MDs2XDvHsyfb/0OB94D3gE2WdY0YAIEuRL/tC5yxI4d0pbz862nF4E3kQf5JgCZwC4bsz2wIE6OaG6GzZvluALy/XYXKLbrGUAlMAmCi2BWQyROjliyBBYtguxsactlZcAhy2lAHvqOfqestPWcBvs6yRFNTbDG5oh162DGDOAFHuQIDljWUuAEBBskZjlxcsTIkXJcIhHJxQB8FXgGyLOsdKAagjFgzkBWFzmioACqqiArCzgr+2H7EXzOMhfb+BfBljg5orYWbt2CEpsjSkuRc30ycAlYEROzeggug1kqqx1zREmJxBCkns3NEmdA2u5cy6pFvpcP2Tp36EeYCrg+DSIzZbrN/Hz7vTAMOAkctW0iB5hq28Y8iT9d5Iht22DcODnPQLhVVXLuJaSE7nl30Msvv2y+8IUvmAsXLjz0eU/dgv/Zz35mWltbHyyXLl2SS7wdLjG3JXmJON7zEqnwfGBp9qaVpdlbb7GivM5uAfW1t4HC0uxNK0uzN60szd60snrbW2efx3sG1HU9Yxfnt+CNMZSVldHQ0MDx48f54he/+ND23/zN32TQoEF897vfffBZc3MzLS0tTJ06FYCpU6fyox/9iCtXrjwoc+zYMYYPH85zzz3X6d/NyMhg+PDhDy2d6XYylbHlTewHex/dHrJ6jucDyzVPK+tCNyyAryXB01pPrSzXPB9Yrnk+sFzzfGC55l3rhmVithu6nibYdT2TVVId0JdffplvfOMbfPOb3+TTn/40H3/8MR9//DG3b4vNESNG8NJLL7Fs2TL+5m/+hu9///v88R//MVOnTuU//If/AMCsWbN47rnnKCws5P333+fdd99l7dq1vPzyy2RkZCRdgdhgP5/kvtHyDxijUuf5wNLsTStLszeXrN9Dhu+IZcWyz5LcPOla66mVpdmbVpZmb1pZmr1pZbnmTe+GVQ18iHQ8P4Qupwl2Xc+klfB9d2Oivh5Z/uIv/uJBmehA9CNHjjRDhgwxeXl55vLlyw9x/vVf/9V86UtfMoMHDzaf/exnzfLly1MaiP4T2t/USnW4gGza3wRrW/V4PB9Ymr1pZWn25pL1NJjzHVh3wWwluSGYtNdTK0uzN60szd60sjR708pyzXuO9rfho6yr9vO+rmd06fFhmPpKPTUT0rPPhqyB4k0rS7M3rSzN3rSyNHvTytLsTStLszetLM3eXLLCDmiSi9apu7SyNHvTytLsTStLszetLM3etLI0e9PK0uxNK0uzN9VTcYYKFSqUaw0F1gItyMhXLXY9lek7Q4UKFSpUP1EvXLB0rp66Avr88yFroHjTytLsrS9YQ8F8DxkmxPDwsCHfo/3Z0f5ez95mafamlaXZm1aWZm9aWZq9uWSFV0CT1LhxIasveT6wXPP6O6scGVP8iQ6fP2E/L0+Sl4h8YLnm+cByzfOB5ZrnA8s1TysrEYUd0BhFR/MPWX3D84HlmtffWV/m0c5nVGm0T9/Z3+vZ2yzXPB9Yrnk+sFzzfGC55mllJaKwAxoqVKg+U2fzE0cVb/7iUKFChQrV/xUYY0xfm0hW169fZ8SIEc65GRkyT2rI6hueDyzXvP7OakGmuu5MBvhJEPAFY/p9PXub5ZrnA8s1zweWa54PLNc8razW1ta4s1ZGFV4BjdH27SGrL3k+sFzz+jvra8iMHZ3JAH9pf2j293r2Nss1zweWa54PLNc8H1iueVpZiSjsgMYoMzNk9SXPB5ZrXn9nbUfmKb6PdDix/7YBF0aM4GtDh/aZt/7Mcs3zgeWa5wPLNc8HlmueVlYi6tcd0E+QL6qbQHaKjGy7fxvwB02Px/OBpdmbVpZmby5ZTwPnO7DuAluJP6bnTWSe4gra5y/+CNgydCjLg4AffPSRunpqZWn2ppWl2ZtWlmZvWlmavbmuZ1Lq8UE7e0DRcUBbkTED2+yS7Nyl2TH7GjBmbOo8H1iavWllafbmkvU0MnZnR1aU90OSmw9eaz21sjR708rS7E0rS7M3rSzN3lzXM3YZ8FNxRjug0YDdTDJAN2MDD8ZEUuf5wNLsTStLszeXrHNdsKK8tQOgnlpZmr1pZWn2ppWl2ZtWlmZvrusZu3g3EP3gFMoHjng+sFzzfGC55mllje+GBe1jeiYy9abWemplueb5wHLN84HlmucDyzVPKysVpfcwv2e1HxgCFEBQBSYLKs9CdTXs3i1Fampg0CBYvFjWi4rg1VdhwgTgHLAR2Gd5PwLmACVyUEwpbCiByZPh0iVYsQIOHJCi9fVw+TIsXWr3LQcWAjnAFWA3EJFNQQRMM0RWyvqqVTB3LkyfDtevQ2EhHDoE6enw7rtAI/Ca5VYgD8dFgDsQ5IOpg8gwOHkSjh6FykopumkTTJoE8+bJem4usBcYBZwGDgKjLWsbBOPALJDV/Hx5Ay4zE5qa4K23JI4Au3bBiBFQUGA9FQLrkV7HzyyzxsZsL+TaOAMUF8OyZTBxIly4AK+/DrW1llMHtAKldv1btr5TIPgITDlE6mXTwYPQ0iIsgOXLZdDcqVPh6lWgqD3eHAb+Jib+a8DMgsjzcOOG1KO+XoacOHYMTp2Cigop+8Yb9hjORnpH84FhlvUeBO+A2SSrW7ZIO8rNlX3z8mDPHhg9GhobYf/+mLcKdwBjgHwbr8HAmxCMBfM+ZO6ROIMwhgyRdgHSdteuhWefBZqBzfa4ArwPzAOKbfy/ApVl0g4uXoTVq6GuToru3y+xKiuz+y4BFiEP+1wG9sTErAHMeYi8IusrV0o9p02Da9fEU0MDpKXBkSPIm0RrLHcd8BPLug28CMEB+MJgWHEc/ugEPLfBJr5KGDsFNsyBZW0wNg/+bB8wEjhlGVtszKYDz0CQJz+x0+dLGx0zBs6cgbffhp07xUJ1NYwaBQsXWk8FQBWQBdyyx2K3jVkN5MXJEefOwcaNsG+f5dTa/Uvsej2wAZgMwSUwKyASJ0eUl4ufnBy4csUyGiwnApyMif8qMHMhEidHNDbCazZHVFTIcWEmcAdpY3U2ZsuAoxBUSsymdpIj9u6VWJ0+LefZ1q3W0zZgHLDAsjKA7RBkgmmCsV3kiMJCWL8exo8HPrCsGsttwiYJG/9i2BQnR9TVQWsrlEZzRBnwEjJN1keWGY3ZQTAtEImTI4qKIGLLHj4MZ88Cqyx3DTDL1rMO+U6pB5MBZZ3kiJwcmD0b7t2D+fOt3+HAe8A7wCbLmgZMgCBX4p/WRY7YsUPacn6+9fQi8CYyTtkNIBPYZWO2BxbEyRHNzbB5sxxXQL7f7gLFdv0AUAlMguAimNUQiZMjliyBRYsgO1vaclkZcMhyGpCHvqPfKSttPafBvk5yRFMTrLE5Yt06mDEDeIEHOYIDwFPAUuAEBBskZjmVMGUKzJkDbW2SZ/ftg5Ej5bhEIpKLAfgq8AyQZ1npQDUEY8CcgawuckRBAVRVQVYWcFb2w/Yj+L5lLrbxL4ItcXJEbS3cugUlNkeUliLn+mTgErDCeosA9RBcBrNUVjvmiJISiSFIPZubJc6AtN25llULFEJwCEw6lMbJETNnyjBL+fn2e2EYkneO2jbxFDDVto15En+6yBHbtsnsSdEB7PPzJYbLl5OYeuGOuXPFuwXfluQl4ocuPYMx+anzfGBp9qaVpdlbb7GivBbkNnzHed+jyz3ab9P3x3qG7ax/sTR708rS7E0rS7M31/WMXby7BX87hfIm9oOCR7eHrJ7j+cByzdPKutANC2TMz0Sn3tRaT60s1zwfWK55PrBc83xgueZpZaWift8BjXa3AZ5Pct9o+VhGqjwfWJq9aWVp9uaS9XvI8B2x+8fyziJjfiY69abWemplafamlaXZm1aWZm9aWZq9ua5n0uqFO+bOFb0F/wntb2qlOlxANu1vgrUNfzyeDyzN3rSyNHtzyXoazPkOrLtgttI+BFMLnd9+N7TfptdeT60szd60sjR708rS7E0rS7M31/WMLgN+GCbXy/btIWugeNPK0uytN1iJPgPa3+vZ1yzN3rSyNHvTytLsTStLszeXLO+eAX1cjR8fsvqS5wPLNa+/sbbT+dSb9+3n2/vQ20Biueb5wHLN84HlmucDyzVPKysRhR3QGH3wQcjqS54PLNe8/sa6yaNTb35o12fY7X3lbSCxXPN8YLnm+cByzfOB5ZqnlZWQeuGOuXP11C340aND1kDxppWl2ZtWlmZvWlmavWllafamlaXZm1aWZm8uWeEzoEkukUjIGijetLI0e9PK0uxNK0uzN60szd60sjR708rS7M0lK3wGNFSoUKFChQoVKpQ+9cIFS+fqqSugubkha6B408rS7E0rS7M3rSzN3rSyNHvTytLsTStLszeXrPAKaKhQoUKFChUqVCh96oULls4VPgOqg6XZm1aWZm9aWZq9aWVp9qaVpdmbVpZmb1pZmr2Fz4CGChUqVKhQoUKFGtjqhQuWztVjU3GOdjil1QBlafamlQWY58Bc7cC7aj8fKPUMY9a3rKFg/hTM7RjefTB/A2b0AKpnmM/CmPU3lmZvrusZXQb8MEyttM8h3ZZCwLJj9jVgzKbUeT6wNHvTygLpMHXFS6ZDpbWeYcz6ljUUzD/GsjrwbpBcJ1RrPcN8Fsasv7E0e3Ndz9jFmw5oNGA3kwxQtNcfZZhI6jwfWJq9aWVB+1W8eLyrA6CeYcz6lrUWudppuuB9ZwDUM8xnYcz6G0uzN9f1jF28ewZ0cArlg9gPLqTO84HlmucDC2BkN7yRSbC01jOMWd+yvkwn8yp34M0AWoB79t+1wNBe8KaV5ZrnA8s1zweWa55WVipK72F+z2o/MAQogKAKTBZUnoXqati9W4rU1MCgQbB4sawXFcGrr8KECcA5YCOwz/IOAXOAEjkophQ2lMDkyXDpEqxYAQcOSNH6erh8GZYutfuWAwuBHOAKsAKIyKYgAqYZIitlfdUqmDsXpk+H69ehsBAOHYL0dHj3XaAReM1yK4CPLOsOBPlg6iAyDE6ehKNHobJSim7aBJMmwbx5sp6bC+wFRgGngYPAL1vWNgjGgVkgq/n5sH07ZGZCUxO89ZbEEWDXLhgxAgoKrKdCYD0wHmmwo4EaG7O9kGvjDFBcDMuWwcSJcOECvP461NZaTh3QCpTa9f9m6zsFgo/AlEOkXjYdPAgtLcICWL4cFiyAqVPh6lWgqD3eHAbeiYn/GjCzIPI83Lgh9aivh4wMOHYMTp2Cigop+8Yb9hjORr6p5wNjLOs9CN4Bs0lWt2yRdpSbK/vm5cGePTB6NDQ2wv79ElMAdlhOPnLWDQbehGAsmPchc4/EGYQxZIi0C5C2u3YtPPss0AxstscVoB6YBxTb+H8FKsukHVy8CKtXQ12dFN2/X2JVVmb3XQIsArKBy8DqmJg1gDkPkVdkfeVKqee0aXDtmnhqaIC0NDhyBGgC1ljuOuBjy7oNwYtgDkBkMBw/DidOwIYNUrSyEqZMgTlzoK1NYrhvH9LDPGUZW2zMpgPPQJAnP7HT50sbHTMGzpyBt9+GnTuFW10No0bBwoXWUwFQBWQB/2KPxW4bsxrIi5Mjzp2DjRutJ4Ba4BZQYtdfBTYAkyG4BGYFROLkiPJy8ZOTA1euWEaD5USAv46J/yowcyESJ0c0NsJrNkdUVEDmNGAmcAdpY3XAk8Ay4CgEldJBHbsJmARj54nt3Fxo/ouAz3wWBv2d4Ve/Bb+41XraBowDFtj4ZwDbIcgE0wRju8gRhYWwfj2MHw98YFk1lnsAmyRs/IthU5wcUVcHra1QGs0RZcBLwBQkL74eE7ODYFogEidHFBVBxJY9fBjOngVWWe4aYBaSH+ukvQT1YDKgrJMckZMDs2fDvXswf771Oxx4D8k9m2zMpgETIMiVNpvWRY7YsUPacn6+9fQi8CYwFvgnIBPYZWO2BxbEyRHNzbB5M+yN5oh9wF2g2K6vACqlHQQXwayGSJwcsWQJLFoE2dnSlsvKkO9JkLZ7nvbvlJW2ntNgXyc5oqkJ1tgcsW4dzJgBvADctnU9AHwaWAqcgGCDxCwnTo4YOVKOSyQiuRiArwLPAHk2/ulANQRjwJyBrC5yREEBVFVBVhZwVvbD9iOos8zFNv5FsCVOjqithVu3oMTmiNJS5FyfDFyy8Y/GrB6Cy2CWymrHHFFSIjEEqWdzs8QZkLY717JqgUIIDoFJh9JOcsS0aTBzJty5I22srg4YBpwEjto2kQ5MtW1jnsSfXGlLo0bB6dPyXbzV5oht22DcODnPQLhVVXLuJaReuGPuXPFuwbcleYn4oUvPnVx+TobnA0uzN60szd60sjR708pq6cjqhPfIdjD3wGwdMsT8KCPD3ItTRlM9w3YWxqy/sTR7c13P2MW7W/C3UyhvHPF8YLnm+cACuNYN71oSLK31DGPWt6yvAW1dbA/ifJ4GFN++zcQ7d3giib83EGLmmucDyzXPB5ZrnlZWKur3HdBodxvg+ST3jZZ/wKhLnecDS7M3rSyQO8dd8aZ3tlMveNPKgjBmybK2Az/i4f078jpTAAwzJm7nU1s9w3zWtyzN3rSyNHtzXc+k1Qt3zJ2rx8YBnf14PB9Ymr1pZUGHMS0t7x6YncgQOgOhnr0RMyfjgCqqp0vWI+OAzpY3428T/9Z69DZbvO0GffUM81kYs/7G0uzNdT2jy4Afhsn1onVKK60szd60sYaC+R7S6Yx9zuae/TzZTqjWevYES7M3raxY3lqI+3znPTCtQdBl57NFcT3DdhbGrL+xNHsLp+IMFWoAqhx5cbfjrc4n7Oflve4olC/ajgxScB/5ZsD+e99+Xm3/35nakOdLQ4UKFcq5euGCpXP11BXQsWND1kDxpo310FvKYzu/yjQQ6tkTLM3etLI68oYiV0JbkKueLXZ9KA9fnY/ejo8+IhK9Oq+1nmE7C2PW31iavblkhVdAk9RLL4WsvuQNZNbnHwI+vC3ouD0JaatnT7Bc83xgdeTdRIY8HocM9TfOrt+0ywxkCN4PkauhH9r1GXa71nqG7axvWa55PrBc87SyElHYAY3RlCkhqy95A5n1cRAzEE4HngF+kiJXWz17gjUU+M9TEp/FpztprWdfnptddVBde9PKcs3zgeWa5wPLNU8rKxGFHdAYffRRyOpL3kBm7U1Pbx+nsQPvcZ6z01ZP16yhwAnglz+SCWGeQP6tsJ+n0gnVWE/XLNc8H1iueT6wXPN8YLnmaWUlpF54ZNO5euoZ0IyMkDVQvGljDQPzg7Q0ec4uo/Pn7AZCPV2zHrzBndH5G9xrB0g9XbM0e9PK0uxNK0uzN60szd5cssJnQJNUfX3I6kveQGbdAKa3tVEB/Ky+8+fs+sqbZtaXsSMHdMJLs9uTlcZ6uma55vnAcs3zgeWa5wPLNU8rKxGl9+6fCxXKX0Wfs/stILePvfQXdfVy1uO8vBUqVKhQofpW4RXQGB08GLL6kucDyzVvoLMevJzVCc+Q2stbGuvpmuWa5wPLNc8HlmueDyzXPK2shNQLj2w6V8epOFOdng86TPf3/OPxfGAB5mkw5zrwztnPB0o9XcdMqzetrCgvOkWcef7xngHVWs+wnSXPehp3+UdzPbWyNHvTytLs7Wncnk/RZcBPxdnKw/MZJxv852L2NbRPkZgKzwdWtLHei8O710Wj7Wwg7B1K6+k6Zlq9aWV1xYtta4m+vKW1nmE7S571NKnln/5WT60szd60sjR76+p8up9CPWMXb15Cio6w+F6S+0XLBx0+T4XnAwvgu8hzG53x0uz2jooOpVPBw0PplDn0pjlmWr1pZXXFi+oOib+8pbWeYTtLnpVK/uktbz6wXPN8YLnmuWR9h/jnUwB8n9THW05IvXDB0rk6XgGN7f2TxNIWs78BY55NnecDK1Xeg6F0uluU1FNDzHxmafamlaXZm1aWZm9aWZq9aWVp9tYVK8pLZag7SOwKaP9+C34/MAQogKAKTBZUnoXqati9W4rU1MCgQbB4sawXFcGrr8KECcA55LXkfZb3U+CbQIn0/k0pbCiByZPh0iVYsQIOHJCi9fVw+TIsXWr3LQcWAjnAFeAC8B9kUxAB0wyRlbK+ahXMnQvTp8P161BYCIcOQXo6vPsu0Ai8ZrkVdgG4A0E+mDqIDIOTJ+HoUaislM2bNsGkSTBvnqzn5gJ7gVHAaeRFjoit9zYIxoFZIB/l58P27ZCZCU1N8NZbEkeAXbtgxAgoKLA+CoH1wHhgBJAP1NiY7ZU3vIuKpGhxMaxYBk9MtDF5Hai1nDqgFSi16z+WOjIFgo/AlEPEDgtx8CC0tMCyZbK+fDksWABTp8LVq0CRrRvAYWGQaeO/BswsiDwPN25IPerrISMDjh2DU6egwsb4jTfsMZyNTLszHxkC6BLwHgTvgNkkf2rLFmlHubmyb14e7NkDo0dDYyPs3y8xBWAHMMbG6lkgG3gTgrFg3ofMPRJnEMaQIdIuQNru2rXw7LNAM7DZHleA68BfAsU2/l+ByjJpBxcvwurVUFcnRffvl1iVRS89LwEWWS+XkSmGftvGrAHMeYi8IusrV0o9p02Da9fEU0MDpKXBkSNAE7DGctch51UbcBuCF8EcgMhgOH4cTpyADRukaGWlzL4xZw60tUkM9+0DRgKn7DHdYmP2FeAZCPIkw6XPlzY6ZgycOQNvvw07dwq3uhpGjYKFC62nAqAKyAI+bdd325jVQF6cHHHuHGzcaD2BtN1bQIld/1+2nUyG4BKYFRCJkyPKy8VPTg5cuWIZDZYTQYZH+LyN/yowcyESJ0c0NsJrNkdUVMhxYSZy/uQj59avA28BRyGolJhN7SRH7N0rsTp9Ws6zrVutp23IlEgLbPx/A9gOQSaYJhjbRY4oLIT162H8eOADy6qx3FbgEFBk418Mm5bBxIlw4QK8/jrU2hxRVwetrVAazRFlyFS2U5AJHX5i4wYEB8G0QCROjigqgojNEYcPw9mzwCrLXQPMsux/lPYR1IPJgLJOckRODsyeDffuwfz51u9w5PLTO8AmG7MvAxMgyJX4p3WRI3bskLacn289vQi8idwuGoacq7tszPbAgjg5orkZNm+W4wrI99tdoNiun7X/ToLgIpjVEImTI5YsgUWLIDtb2nJZmT12IG33PLAb+U5Zaes5DfZ1kiOammCNzRHr1sGMGcALwG1b1wPAryGzcpyAYIPELCdOjhg5Uo5LJCK5GICvAs8AeTb+k4FqCMaAOQNZXeSIggKoqoKsLBujals3gGvIObrYxr8ItsTJEbW1cOsWlNgcUVqKnOuTke+RFbR/D9dDcBnMUvmoY44oKZEYgtSzuVniDEjbnQv8MfADoBCCQ2DSoTROjpg5E+7ckTZWV2fb1UngKFBpY/ZfpG1gc8SXc2F8nByxbRuMGyfnGQi3qkrOvYTUCxcsnauzK6DR3jqP0/uPpM7zgZUqL6Grn4rqqSFmPrM0e9PK0uxNK0uzN60szd60sjR7645lkO/vZOoaXbx5BhSkxm1J7vNI+aup83xggQyg3hXvke0kMVSOknq6jplWb1pZrnk+sFzztLJSyT9dSWs9tbJc83xguea5ZF2w+3TGivJSGeouYfXCBUvnivcM6M4ke+g7O/sFkCLPBxZgtnbD29rJPl09A6qxnq5jptWbVpZmb1pZmr25ZKWSf/pjPbWyNHvTytLs7Wnkbfd4vFSnOwZPhmFqs8tZkp9Pe6jdL8owkdR5PrCivB/G4f0wDm8oMmRO7HAPbXb9ZhzWQIuZRm9aWZq9aWVp9uaalWz+6a/11MjS7E0rz9UQigAAJ3FJREFUS7u358DcjvI6DGuW6FB3nS0DvgP678h4kmsfI0ix41O2RR6P5wMrVV5n44CuBTNaaT01xMxnlmZvWlmavWllafamlaXZm1ZWf/F2K/Lw93OqPPCgA+p6KS4OWQPFm1aWZm9aWZq9aWVp9tYTrHg/cJP9AtVeT20szd60sjR7c8ka+MMwOdbZs92XCVk9x/OB5ZrnA8s1zweWa55m1lBkoospyCQXICMXVSBDws0gsQkLesLbQGe55vnAcs3TykpIvXDB0rl66gpoJBKyBoo3rSzN3rSyNHvTytLszTWrq5cck32JQnM9NbI0e9PK0uwtGVa8uw5D7HavhmEKFSpUqFD+6cu0X/nsqDS7PVSoUO4UvetQwcPTa1cg8zAkrF64YOlcPXUFdNKkkDVQvGllafamlaXZm1aWZm+uWd1NdJHMQNqa66mRpdmbVpZmb4myurrr8O+2THgFNEnNmhWy+pLnA8s1zweWa54PLNc8zayuBso2JDeQtuZ6amS55vnAcs3rC1Z3dx0SVdgBjdHzz4esvuT5wHLN84HlmucDyzVPM+trxJ8BqQ3ZngzPlXxgueb5wHLN6wvW57vYFiTx98IOaIxu3AhZfcnzgeWa5wPLNc8HlmueZtZ2oAnphBr7ubHrTcj2vvI20FmueT6wXPP6gtXdXYdEFRhjkimvQtevX2fEiBF9bSNUqFChQinQUKAcuTX4eeQL8mtI5zPRIZhChQqVmNYiLxx1dhv+GvAZoLW1leHDh3fJCa+Axqi+PmT1Jc8HlmueDyzXPB9YrnnaWTeBjcA4IN3+u5HkO5/a66mN5ZrnA8s1ry9YXd11eD+Jv9evO6CfIM/43ASyU2Rk2/3bgAUZj8fzgaXZm1aWZm9aWQDPAVc78K7az/vSm1aWZm9aWZq9aWVp9qaV5ZrX17nxJjLBQwXwIdLx/NCuz03mj/f4mEk9oOgwTK32tf82u2QnOeRAdsy+BowpS53nA0uzN60szd60sgDzXDe852LKBkFg0tPTTXp6ugmCoN/UM2xnYcz6G0uzN60s17xkcmNv1zN2GfBzwUc7oNGA3UwyQDdjAw/GTEmd5wNLszetLM3etLIAc7Ub3tWYskOGDDGTnn7abP/MZ8yHQfDIXOBa6xm2szBm/Y2l2ZtWlmteMrmxt+sZu3jXAW1LMkAPBR6MiaTO84Gl2ZtWlmZvWlnJ8j4/fLj58ZAhjwyMfA/M9xTXM2xnYcz6G0uzN60szd5c1zN2SaQDmk5/1n5gCFAAQRWYLKg8C9XVsHu3FKmpgUGDYPFiWS8qgldfhQkTgHPIk+r7LG8MMAcokbGsTClsKIHJk+HSJVixAg4ckKL19XD5MixdavctBxYCOcAV+1lE/gkiYJohslLWV62CuXNh+nS4fh0KC+HQIUhPh3ffBRqB1yyjAviiZd2BIB9MHUSGwcmTcPQoVFZK0U2bYNIkmDdP1nNzgb3AKOA0cND6iwDbIBgHZoGs5ufD9u2QmQlNTfDWWxJHgF27YMQIKCiwngqB9cB4YCIwGqixMdsLuTbOAMXFsGwZTJwIFy7A669Dba3l1AGtQKldH2zrOwWCj8CUQ8Q+FH3wILS0CAtg+XJYsACmToWrV4Gi9nhzGBgZE/81YGZB5HkZZqKgQI5fRgYcOwanTkFFhZR94w0bo9nAPWA+8BuW9R4E74DZJKtbtkg7ys2VffPyYM8eGD0aGhth/36JKQA7kPaVb/mDgTchGAvmfcjcI3EGYQwZIu0CpO2uXQvPPgs0A5vtccUy5wHFNv5fgcoyaQcXL8Lq1VBXJ0X375dYlZXZfZcAi5CHfS4jgGjMGsCch8grsr5ypdRz2jS4dk08NTRAWhocOYI8kb7GctfZthEBbkPwIpgDEBkMx4/DiROwYYMUrayEKVNgzhxoa5MY7ttnj98py9hiYzYdeAaCPMlw6fOljf5O5k95ttGQ9jaw03qohidGwW8utOsFQBWQBfyKjdtuG7MayIuTI86dg40brSeAWuAWUGLXPwVsACZDcAnMCojEyRHl5bBwIeTkwJUrltFgORHk1dFo/FeBmQuRODmisRFeszmiokKOCzOBO0gbq7MxWwYchaBSYja1kxyxdy+MGgWnT8t5tnWr9bQNeZtngWVlANshyATTBGO7yBGFhbB+PYwfD3xgWTWW+4vYJGHjXwyb4uSIujpobYXSaI4oA14CpgAfIW8xRGN2EEwLROLkiKIiiNiyhw/D2bPAKstdA8yy9axDvlPqwWRAWSc5IicHZs+Ge/dg/nzrdzjwHjIX4SbLmgZMgCBX4p/WRY7YsQPGjJFcDMCLwJvIHIcTgExgl43ZHlgQJ0c0N8PmzXJcAfl+uwsU2/UMoBKYBMFFMKshEidHLFkCixZBdra05bIy4JDlNADnaf9OWWnrOQ32dZIjmppgjc0R69bBjBnAC8BtW9cDlrUUOAHBBolZTpwcMXKkHJdIRHIxAF8FngHyLCsdqIZgDJgzkPU27LQ5orpa2v1CmyMKCqCqCrKygLOyH7Yfwecsc7GNfxFsiZMjamvh1i0osTmitBQ51ycDl4AVMTGrh+AymKWy2jFHlJRIDEHq2dwscQak7c61rFqgEIJDYNKhNE6OmDkT7tyRNlZXBwwDTgJHbZvIAabatjFP4k8XOWLbNhg3Ts4zEG5VlZx7CakXLlg6V49dAc12+EtiALI0e9PK0uxNKytZ3qWOZXm0rMZ6hu0sjFl/Y2n2ppWl2ZvresYu3k3FeTuF8ib2g5zUeT6wXPN8YLnm+cACGUuuK961mP+P6YIT0J4RXXjTHDOt3rSyXPN8YLnm+cByzUsmN/amr1TU7zugsV8uzye5b7T8A8bs1Hk+sDR708rS7E0rC+Rue1e86TFlu5uV40rM/zXVM2xnfcvS7E0rS7M3rSzXvO5y4+w+8pWK+nUHNBqk20jH/UyS+5+x+0V7+eZe6jwfWJq9aWVp9qaVBfBjYBLtv+ajvGv28x/HlO1uLvA/c+hNc8y0etPK0uxNK0uzN60s17wf233uRT+4J3d6AiTf/TkyM1hv+0pF4VScoUKF6tcaCpxA3ktJo/22exvybtQMwukYQ4UKNXDU1VSY9+22jb3opzOFU3EmqQdvZ4esPuH5wHLN84HVHa+rWTlm8GjnU2s9w3bWtyzXPB9Yrnk+sFzwvkxM57MDK81uT0Wu69md+vcwTI7VTWc9ZPUwzweWa54PrER4N5Ff/In86tdaz7Cd9S3LNc8HlmueDywXvM8/BHt4W9BxexJyXc/uFF4BjdF774WsvuT5wHLN84HlmucDyzXPB5Zrng8s1zwfWC54lx+CPbzN0PWLmV3JdT27VY8P2tkDio4D6nqZODFkDRRvWlmavWllafamlaXZm1aWZm9aWZq9aWW54K1LSzP3g0DG7Jz48Fie95BpiPu6ngN+Kk7XSyQSsgaKN60szd60sjR708rS7E0rS7M3rSzN3rSyXPCGgTn7qU+Z+2DaIu0Dx0enHx6qoJ7eDUQfKlSoUKFChQo1kHUD+O2f/YzXgZ/R/YuXatULFyydq6eugE6bFrIGijetLM3etLI0e9PK0uxNK0uzN60szd60sjR7c8kKr4AmqQkTQlZf8nxgueb5wHLN84HlmucDyzXPB5Zrng8s1zytrEQUdkBjlJsbsvqS5wPLNc8HlmueDyzXPB9Yrnk+sFzzfGC55mllJaJ+3QH9BJnt5CaQnSIj2+7fBvzBY/Jcsp4DrnZgXbWfRzUUmRGhBZmWq8Wud5yGy6Uv17xE6tkXvjTHzAeWZm9a26xrng8s1zytbUNzzHxgafbmup5JqRce2XSu6DOgrbS//dUGJjvJZxSyY/Y1YExa6jyXrOe6YT2HvOX2PeStN8PDQzDEvgXn0ldf1LO/H0vN3rSyNHvT2mY1x0wry5e2oTlmPrA0e3Ndz9hlwA/DFO2ARgN2M8kA3YwNPBhTkzrPJetqN6yryDhfHTuf0SV2HDCXvvqinv39WGr2ppWl2ZvWNqs5ZlpZvrQNzTHzgaXZm+t6xi7evYQ0OIXyQewHo1PnuWSN7IY1kg5zwXZQ7FywLn255iVSz77wpTlmPrBc83xos655PrBc87S2Dc0x84HlmqeVlYr691zw+4EhQAEEVWCyoPIsVFfD7t1SpKYGBg2CxYtlvagIXn3Vvu11Dpk8ep/l3QTmACVyUEwpbCiByZPh0iVYsQIOHJCi9fVw+TIsXWr3LQcWAjnAFeB7QEQ2BREwzRBZKeurVsHcuTB9Oly/DoWFcOgQpKfDu+8CjcBrlluB9CgjwB0I8sHUwReGASeBo0ClLbsJmATBPPgCQC6wFxgFnAYOAr9kWdsgGAdmgazm58P27ZCZCU1N8NZbEkeAXbtgxAgoKLB/pxBYD4wHnkQabY2N2V75s0VFUrS4GJYtg4kT4cIFeP11qK21nDqgFSi16822vlMg+AhMOUTqZdPBg9DSIiyA5cthwQKYOhWuXgWK2uPNYWSusmj814CZBZHn4cYNqUd9PWRkwLFjcOoUVFRI2TfesMdwNvJg7XxgnGW9B8E7YDbJ6pYt0o6iD27n5cGePTB6NDQ2wv79ElMAdgBjgHx7DAYDb0IwFsz7kLlH4gzCGDJE2gVI2127Fp591sZosz2uIAPCzQOKbfy/ApVlMGkSXLwIq1dDXZ0U3b9fYlVWZvddAixCHva5DJyJiVkDmPMQeUXWV66Uek6bBteuiaeGBkhLgyNHgCZgjeWuQ34dRYDbELwI5gBEBsPx43DiBGzYIEUrK2HKFJgzB9raJIb79iHf1qcsY4uN2XTgGQjy5Cd2+nxpo2PGwJkz8PbbsHOncKurYdQoWLjQeioAqoAsYIQ9FrttzGogL06OOHcONm60ngBqgVtAiV3/J2ADMBmCS2BWQCROjigvFz85OXDlimU0WE4E+LeY+K8CMxcicXJEYyO8ZnNERYUcF2YCd5A2Vmdjtgw4CkGlxGzqJmkb8+bJvrm5sHevxOr0aTnPtm61nrYhbX+BZWUA2yHIBNMEY7vIEYWFsH49jB8PfGBZNZb7U2ySsPEvhk1xckRdHbS2Qmk0R5QBLwFTgI+AH8TE7CCYFojEyRFFRRCxZQ8fhrNngVWWuwaYZetZh3yn1IPJgLJOckRODsyeDffuwfz51u9wZFrEd5Bc/EvANGACBLkS/7QucsSOHdKW8/OtpxeBN4GxwKeBTGCXjdkeWBAnRzQ3w+bNclwB+X67CxTb9Q+Q74xJEFwEsxoicXLEkiWwaBFkZ0tbLisDDllOA3Ce9u+Ulbae02BfJzmiqQnW2Byxbh3MmAG8ANy2dT1gWUuBExBskJjlxMkRI0fKcYlEJBcD8FXgGSDPstKBagjGgDkDWV3kiIICqKqCrCzgrOyH7UfQapmLbfyLYEucHFFbC7duQYnNEaWlyLk+GbgErIiJWT0El8EsldWOOaKkRGIIUs/mZokzIG13rmXVAoUQHAKTDqVxcsTMmXDnjrSxujqgYz/il4CpPOhHGIAucsS2bTBunJxnINyqKjn3ElIv3DF3rni34NuSvET80KVnMGZ86rzeZrV0LNMhFi094Ku/x6wvWJq9aWVp9qaVpdmbVpZmb1pZmr1pZWn25rqesYt3t+Bvp1DexH6wPXWeS9a1bljXgK8hsx90pja73bUv17xE6tkXvjTHzAeWa54PbdY1zweWa57WtqE5Zj6wXPO0slJRv++ARrvbAM8nuW+0fCwjVZ5L1vRuWNORdtKEdEJjy9y3n0fbkUtfrnmJ1LMvfGmOmQ8szd60tlnXPB9Yrnla24bmmPnA0uzNdT2TVi/cMXeu6C34T2h/UyvV4QKyaX8TrO2Fx+O5ZD1H+1uVUdZVHh7KYyjytnsL8uZ7i10fSs/56ot69vdjqdmbVpZmb1rbrOaYaWX50jY0x8wHlmZvrusZXQb8MEyul4KCkDVQvGllafamlaXZm1aWZm9aWT3lLdELBWHM/GBp9uaS5d0zoI+rB28fhqw+4fnAcs3zgeWa5wPLNc8Hlmtefr7MSncCGdxjLDI4xFi7foJHZ63rLV8updWbVpZrnlZWIgo7oKFChQoVKlQPqBwZMarjmM1P2M/Le91RqFB6FBhjTF+bSFbXr19nxIgRzrmDB8NtR699+cByzfOB5ZrnA8s1zweWa54PLNe8wYOh+bZc8exMBvgQGWq1t31pjtlAZ7nmaWW1trYyfPjwLsuEV0Bj9OabIau3eUOBtUALcONN+Xctid+a6ilfPcVyzfOB5ZrXW6zYtn2P7tt2GLO+ZbnmvfkmfL6L7QFdb+/IciXtMRvoLNc8raxE1L9nQnKssfF+qoasHuFFn496cItqbPvzUbnADGRyqt721ZMs1zwfWK55vcF6pG3Tfdv2PWZ9zXLNGzsWfkLXV0B/kgTLlbTHbKCzXPO0shJReAU0Ru+/H7J6k/fI81GW5eL5qIEaMx9Zrnm9wUrl2T/fY9bXLNe8999PfMKQRFiupD1mA53lmqeVlZB6fMykHlBPDcOUmRmyepP3yHSimQ9PA9aSIncgx8xHlmZv8ViJTpUbxkwPqye8DQXzPWT4pei0h212/XskPhSTTzEb6CzN3lyywnFAk1wikZDVm7x7dPhyjjy8fk9JPTXFzEeWZm/xWI+0bbpv277HrK9ZPeXNxTigvsVsILM0e3PJSqQDGj4DGqrP5Or5qFChtCls26GiuglstEuoUKFi1AsXLJ2rx6binONwSqsBynLJW0uHK0VzHr5CtDaMmbcszd4SYT3Stum8bYcxC9tZf2Np9qaVpdmb63pGlwF/C76V9mdq2lIIWHbMvgaMWZA6zweWa970bljTw5h5ydLsLVFWIs/+hTEL21l/Y2n2ppWl2ZvresYu3nRAowG7mWSAor3+KCP2GcRkeT6wNHvTytLsTStLs7dkWN09+xfGLGxn/Y2l2ZtWlmZvrusZu3j3DOjgFMoHjng+sFzzfGC55vnAcs3rK1Z3z/6FMetblmueDyzXPB9YrnlaWamof3dA9wNDgAIIqsBkQeVZqK6G3bulSE0NDBoEixfLelERvPoqTJgAnEO+HfZZXgMwByiRg2JKYUMJTJ4Mly7BihVw4IAUra+Hy5dh6VK7bzmwEMgBrgBFQEQ2BREwzRBZKeurVsHcuTB9Oly/DoWFcOgQpKfDu+8CjcBrllsBnLKsOxDkg6mDyDA4eRKOHoXKSim6aRNMmgTz5sl6bi6wFxgFnAYOAoMsaxsE48AskNX8fNi+HTIzoakJ3npL4giwaxeMGAEFBdZTIbAeGA/8b2A0UGNjtlcG2i4qkqLFxbBsGUycCBcuwOuvQ22t5dQBrUCpXV9j6zsFgo/AlEOkXjYdPAgtLcICWL4cFiyAqVPh6tWH481hYFdM/NeAmQWR5+HGDalHfT1kZMCxY3DqFFRUSNk33rDHcDYyfc184GeW9R4E74DZJKtbtkg7ys2VffPyYM8eGD0aGhth/36JKQA7gDFAvj0Gg4E3IRgL5n3I3CNxBmEMGSLtAqTtrl0Lzz4LNAOb7XHFHtN5QLGN/1egskzawcWLsHo11NVJ0f37JVZlZXbfJcAiIBu4DPyXmJg1gDkPkVdkfeVKqee0aXDtmnhqaIC0NDhyBGiyxw9gHfD3lnUbghfBHIDIYDh+HE6cgA0bpGhlJUyZAnPmQFubxHDfPmAk7e1+i43ZdOAZCPLkJ3b6fGmjY8bAmTPw9tuwc6dwq6th1ChYuNB6KgCqgCzkvB8D7LYxq4G8ODni3DnYuNF6AqgFbgEldn01sAGYDMElMCsgEidHlJeLn5wcuHLFMhosJwL8eUz8V4GZC5E4OaKxEV6zOaKiQo4LM4E7SBurszFbBhyFoFJiNrWTHLF3r8Tq9Gk5z7ZutZ62IfNELrCsDGA7BJlgmmBsFzmisBDWr4fx44EPLKvGcuuxScLGvxg2xckRdXXQ2gql0RxRBryEDKb6kY1hNGYHwbRAJE6OKCqCiC17+DCcPQusstw1wCxbzzrkO6UeTAaUdZIjcnJg9my4dw/mz7d+hwPvAe8AmyxrGjABglyJf1oXOWLHDmnL+fnW04vAm8jbbP8MZAK7bMz2wII4OaK5GTZvluMKyPfbXaDYrq8CKoFJEFwEsxoicXLEkiWwaBFkZ0tbLisDDllOA3Ce9u+Ulbae02BfJzmiqQnW2Byxbh3MmAG8ANy2dT1gWUuBExBskJjlxMkRI0fKcYlEJBcD8FXgGSDPstKBagjGgDkDWV3kiIICqKqCrCzgrOyH7Uew3zIX2/gXwZY4OaK2Fm7dghKbI0pLkXY6GbgErIiJWT0El8EsldWOOaKkRGIIUs/mZonzg+M417JqgUIIDoFJh9I4OWLmTLhzR9pYXR0wDDgJHLVtYhAw1baNeRJ/usgR27bBuHFynoFwq6rk3EtIydz6rqqqMtnZ2WbYsGHmqaeeMrm5ueaf/umfHirz/PPPP3IptqSk5KEyFy9eNHPmzDGDBw82Tz31lHnllVfM3bt3E/YR7xZ8W5KXiB+69AzGbE2d5wNLszetLM3etLI0e9PK0uxNK0uzN60szd60sjR7c13P2CWRW/BJzYR08uRJXn75Zf7+7/+eY8eOcffuXWbNmsXNmzcfKldcXMzly5cfLFse/DyB+/fvM3fuXH7+85/zd3/3d3z9619n3759rFu3Lhkrnep2CuVN7AfPps7zgeWa5wPLNc8HlmueDyzXPB9Yrnk+sFzzfGC55mllpaKkOqDf/va3Wbx4Mb/6q7/K5MmT2bdvHy0tLXz/+99/qNyQIUP4xV/8xQfL8OHDH2w7evQoP/7xj/nGN77Br//6r/OlL32JN954gz/7sz/j5z//edIViHa3AZ5Pct9o+QeM5tR5PrA0e9PK0uxNK0uzN60szd60sjR708rS7E0rS7M31/VMWgnf9+5E//Iv/2IA86Mf/ejBZ88//7z57Gc/a0aNGmV+9Vd/1axatcrcvHnzwfbXXnvNTJ48+SHOhQsXDGB+8IMfdPp3fvazn5nW1tYHy6VLlwz0wDigox6P5wNLszetLM3etLI0e9PK0uxNK0uzN60szd60sjR7c13P6NKjwzDdv3/fzJ0710ybNu2hz/fs2WO+/e1vmx/+8IfmG9/4hsnMzDR5eXkPthcXF5tZs2Y9tM/NmzcNYI4cOdLp33r99dcfKxCJLlqntNLK0uxNK0uzN60szd60sjR708rS7E0rS7M3rSzN3vrNVJwvv/wyZ8+e5W//9m8f+vzLX/7yg///2q/9GmPGjOF3f/d3OX/+PM8880xKf+u//bf/xrLo68/A9evXGTs23kR3oUKFChUqVKhQoVQrhYuf5uWXXzZf+MIXzIULF7ote+PGDQOYb3/728aY1G7Bd1T0LXjXS15eyBoo3rSyNHvTytLsTStLszetLM3etLI0e9PK0uzNJcv5W/DGGMrKymhoaOD48eN88Ytf7Haff/zHfwT4/7d3d7FN1X8YwJ9trHU4uzq7rS24uSGyzI1FUZrGOEnW7CXEoHCBOCMaA2GOxJdJzExkyg0GEy80BO+cFwSRRFxYlGQwOoKW6eYW3rShS2WgLYsje4Ex99KvF393YmFsZf+z9rTn+SRNWM/Zw/fk4Zz8OJwy2Gw2AIDT6cTZs2fR39+v7NPa2gqTyYSioqK7GUd1ExPMimWeHrLUztNDltp5eshSO08PWWrn6SFL7Tw9ZKmdp9WsiER0y/FftbW1kpGRIW63WwKBgPIaHR0VERGfzye7du2Szs5O8fv90tzcLAUFBVJWVqZkTE5OSnFxsVRUVEhPT48cPXpUsrKypKGhIeI5FuoOqFafpdBqlpZn02qWlmfTapaWZ9NqlpZn02qWlmfTapaWZ9NqlpZni/YzoHd1B3Tfvn0YGhrCmjVrYLPZlNfBgwcBAAaDAceOHUNFRQUKCwtRX1+PDRs24MiRI0pGSkoKWlpakJKSAqfTiZdeegkvv/wydk3/aBQiIiIiSmx3cwdUKxbqDqjNxqxEmU2rWVqeTatZWp5Nq1lank2rWVqeTatZWp5Nq1lank3NLNXvgCY65WdkMysmeXrIUjtPD1lq5+khS+08PWSpnaeHLLXz9JCldp5WsyLBBeh/FBczK5Z5eshSO08PWWrn6SFL7Tw9ZKmdp4cstfP0kKV2nlazIsEF6H9cusSsWObpIUvtPD1kqZ2nhyy18/SQpXaeHrLUztNDltp5Ws2KSBQe2VTdQj0Dmp7OrESZTatZWp5Nq1lank2rWVqeTatZWp5Nq1lank2rWVqeTc0sPgN6l/bvZ1Ys8/SQpXaeHrLUztNDltp5eshSO08PWWrn6SFL7TytZkUiLhegIrIguaOjzIplnh6y1M7TQ5baeXrIUjtPD1lq5+khS+08PWSpnafVrEjWaUmyUKu5BXTlyhX+LHgiIiIiDbp8+TKWLl066z5xuQANhULwer0oKirC5cuXYTKZYj0SLYDh4WE8+OCD7DhBsd/Exn4THztObPPpV0QwMjICu92O5OTZ/5F9kRpDRltycjKWLFkCADCZTPyDn+DYcWJjv4mN/SY+dpzY7rbfjIyMiPaLy2dAiYiIiCh+cQFKRERERFEVtwtQo9GIxsZGGI3GWI9CC4QdJzb2m9jYb+Jjx4ltofuNyw8hEREREVH8its7oEREREQUn7gAJSIiIqKo4gKUiIiIiKKKC1AiIiIiiqq4XYDu3bsXDz30EO655x44HA789NNPsR6J5uGDDz5AUlJS2KuwsFDZPjY2hrq6OjzwwANIT0/Hhg0bcPXq1RhOTLM5efIknn32WdjtdiQlJeHbb78N2y4i2LlzJ2w2G9LS0uByuXDx4sWwfa5du4aamhqYTCaYzWa89tpruH79ehSPgmYzV8evvPLKbed0VVVV2D7sWJt2796NJ598Evfddx+ys7Px3HPPwev1hu0TyTW5r68Pa9euxeLFi5GdnY0dO3ZgcnIymodCdxBJx2vWrLntHN62bVvYPmp0HJcL0IMHD+Ltt99GY2MjfvnlF5SWlqKyshL9/f2xHo3m4dFHH0UgEFBep06dUra99dZbOHLkCA4dOoT29nb8+eefWL9+fQynpdncuHEDpaWl2Lt374zb9+zZg08//RSff/45Ojo6cO+996KyshJjY2PKPjU1NTh//jxaW1vR0tKCkydPYuvWrdE6BJrDXB0DQFVVVdg5feDAgbDt7Fib2tvbUVdXh9OnT6O1tRUTExOoqKjAjRs3lH3muiZPTU1h7dq1GB8fx48//ogvv/wSTU1N2LlzZywOiW4RSccAsGXLlrBzeM+ePco21TqWOLR69Wqpq6tTvp6amhK73S67d++O4VQ0H42NjVJaWjrjtsHBQUlNTZVDhw4p7/36668CQDweT5QmpPkCIIcPH1a+DoVCYrVa5eOPP1beGxwcFKPRKAcOHBARkQsXLggA+fnnn5V9vv/+e0lKSpI//vgjarNTZG7tWERk8+bNsm7dujt+DzuOH/39/QJA2tvbRSSya/J3330nycnJEgwGlX327dsnJpNJ/v777+geAM3p1o5FRJ555hl544037vg9anUcd3dAx8fH0dXVBZfLpbyXnJwMl8sFj8cTw8lovi5evAi73Y6CggLU1NSgr68PANDV1YWJiYmwrgsLC5Gbm8uu45Df70cwGAzrMyMjAw6HQ+nT4/HAbDbjiSeeUPZxuVxITk5GR0dH1Gem+XG73cjOzsaKFStQW1uLgYEBZRs7jh9DQ0MAgMzMTACRXZM9Hg9KSkqQk5Oj7FNZWYnh4WGcP38+itNTJG7teNr+/fthsVhQXFyMhoYGjI6OKtvU6njR/zl71P3111+YmpoKO3AAyMnJwW+//RajqWi+HA4HmpqasGLFCgQCAXz44Yd4+umnce7cOQSDQRgMBpjN5rDvycnJQTAYjM3ANG/Tnc107k5vCwaDyM7ODtu+aNEiZGZmsvM4UVVVhfXr1yM/Px+9vb147733UF1dDY/Hg5SUFHYcJ0KhEN5880089dRTKC4uBoCIrsnBYHDGc3x6G2nHTB0DwIsvvoi8vDzY7XacOXMG7777LrxeL7755hsA6nUcdwtQSizV1dXKr1euXAmHw4G8vDx8/fXXSEtLi+FkRDQfL7zwgvLrkpISrFy5EsuWLYPb7UZ5eXkMJ6O7UVdXh3PnzoU9k0+J5U4d//d57JKSEthsNpSXl6O3txfLli1T7fePu3+Ct1gsSElJue1Td1evXoXVao3RVKQWs9mMRx55BD6fD1arFePj4xgcHAzbh13Hp+nOZjt3rVbrbR8mnJycxLVr19h5nCooKIDFYoHP5wPAjuPB9u3b0dLSghMnTmDp0qXK+5Fck61W64zn+PQ20oY7dTwTh8MBAGHnsBodx90C1GAwYNWqVTh+/LjyXigUwvHjx+F0OmM4Ganh+vXr6O3thc1mw6pVq5CamhrWtdfrRV9fH7uOQ/n5+bBarWF9Dg8Po6OjQ+nT6XRicHAQXV1dyj5tbW0IhULKRZDiy5UrVzAwMACbzQaAHWuZiGD79u04fPgw2trakJ+fH7Y9kmuy0+nE2bNnw/6S0draCpPJhKKiougcCN3RXB3PpKenBwDCzmFVOp7Hh6Zi7quvvhKj0ShNTU1y4cIF2bp1q5jN5rBPZFF8qK+vF7fbLX6/X3744QdxuVxisVikv79fRES2bdsmubm50tbWJp2dneJ0OsXpdMZ4arqTkZER6e7ulu7ubgEgn3zyiXR3d8ulS5dEROSjjz4Ss9kszc3NcubMGVm3bp3k5+fLzZs3lYyqqip57LHHpKOjQ06dOiXLly+XTZs2xeqQ6BazdTwyMiLvvPOOeDwe8fv9cuzYMXn88cdl+fLlMjY2pmSwY22qra2VjIwMcbvdEggElNfo6Kiyz1zX5MnJSSkuLpaKigrp6emRo0ePSlZWljQ0NMTikOgWc3Xs8/lk165d0tnZKX6/X5qbm6WgoEDKysqUDLU6jssFqIjIZ599Jrm5uWIwGGT16tVy+vTpWI9E87Bx40ax2WxiMBhkyZIlsnHjRvH5fMr2mzdvyuuvvy7333+/LF68WJ5//nkJBAIxnJhmc+LECQFw22vz5s0i8r//iun999+XnJwcMRqNUl5eLl6vNyxjYGBANm3aJOnp6WIymeTVV1+VkZGRGBwNzWS2jkdHR6WiokKysrIkNTVV8vLyZMuWLbfdHGDH2jRTrwDkiy++UPaJ5Jr8+++/S3V1taSlpYnFYpH6+nqZmJiI8tHQTObquK+vT8rKyiQzM1OMRqM8/PDDsmPHDhkaGgrLUaPjpH8HIiIiIiKKirh7BpSIiIiI4hsXoEREREQUVVyAEhEREVFUcQFKRERERFHFBSgRERERRRUXoEREREQUVVyAEhEREVFUcQFKRERERFHFBSgRERERRRUXoEREREQUVVyAEhEREVFUcQFKRERERFH1DxbdLVaYefj4AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def predict_on_image(model, data_loader, image, tile_size=8, max_hits_per_tile=5):\n", + " \"\"\"\n", + " Given a model, data loader, and an image, slices the image into tiles,\n", + " makes predictions on each tile, and reconstructs the original image from the tiles.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access tile size.\n", + " - image: np.array, the image to predict on.\n", + " - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image from tiles.\n", + " - predicted_centers: np.array, the predicted hit centers in the image.\n", + " \"\"\"\n", + " # Tile the image\n", + " tiles = data_loader.tile_image(image) # Returns an array of tiles\n", + " num_tiles = tiles.shape[0]\n", + "\n", + " # Reshape tiles for model input (assuming model expects shape (batch_size, tile_size, tile_size, 1))\n", + " tiles = tiles.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Normalize tiles (assuming same normalization as during training)\n", + " normalized_tiles = tiles / np.max(tiles)\n", + "\n", + " # Make predictions on tiles\n", + " predictions = model.predict(normalized_tiles)\n", + "\n", + " # Reshape predictions to (num_tiles, max_hits_per_tile, 2)\n", + " predicted_centers = predictions.reshape(num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # Reconstruct the image from tiles (if needed)\n", + " reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + " tiles.reshape(-1, tile_size, tile_size), tile_size\n", + " )\n", + "\n", + " return reconstructed_image, predicted_centers\n", + "\n", + "\n", + "# Load an image (replace with your actual image)\n", + "image = data_loader.images[0] # For example, use the first image from your dataset\n", + "\n", + "# Predict on the image\n", + "reconstructed_image, predicted_centers = predict_on_image(loaded_model, data_loader, image)\n", + "\n", + "# Visualize the predictions (optional)\n", + "def visualize_predictions(image, predicted_centers, tile_size=8):\n", + " grid_size = image.shape[0] // tile_size\n", + " fig, ax = plt.subplots(figsize=(8, 8))\n", + " ax.imshow(image, cmap='gray')\n", + " ax.set_title(\"Predicted Hits on the Image\")\n", + "\n", + " # Overlay the tile boundaries\n", + " for i in range(1, grid_size):\n", + " ax.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " ax.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Plot predicted centers\n", + " for tile_idx in range(len(predicted_centers)):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + " tile_pred_centers = predicted_centers[tile_idx]\n", + " for (x, y) in tile_pred_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='red', marker='o', s=30)\n", + " plt.show()\n", + "\n", + "# Call the visualization function\n", + "visualize_predictions(reconstructed_image, predicted_centers)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 548us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 665us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 682us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 709us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 641us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 686us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 629us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 669us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 642us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 685us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 674us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 712us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 635us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 677us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 663us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 536us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 665us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 731us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 671us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 688us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 636us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 691us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 682us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 674us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 652us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 696us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 716us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 671us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 691us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 689us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 674us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 576us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 669us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 688us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 625us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 665us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 717us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 667us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 622us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 644us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 680us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 726us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 702us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 654us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 691us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 674us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 684us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 688us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 614us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 705us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 658us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 631us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 709us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 669us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 724us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 679us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 636us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 685us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 710us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 632us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 603us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 710us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 663us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 729us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 755us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 779us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 706us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 613us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 697us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 698us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 663us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 668us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 568us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 699us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 649us/step\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 672us/step\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 747us/step\n", + "True Positives: 7671\n", + "False Positives: 304392\n", + "False Negatives: 7753\n", + "Precision: 0.0246\n", + "Recall: 0.4973\n", + "F1 Score: 0.0468\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from scipy.optimize import linear_sum_assignment\n", + "\n", + "def compute_metrics(model, data_loader, val_dataset, tile_size=8, max_hits_per_tile=13, distance_threshold=0.1):\n", + " \"\"\"\n", + " Computes precision, recall, and F1 score for the model on the validation dataset.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model.\n", + " - data_loader: DataLoader instance.\n", + " - val_dataset: Validation dataset as a tf.data.Dataset.\n", + " - tile_size: int, size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - distance_threshold: float, the maximum normalized distance between predicted and true hits to consider a match.\n", + "\n", + " Returns:\n", + " - precision: float, precision score.\n", + " - recall: float, recall score.\n", + " - f1_score: float, F1 score.\n", + " \"\"\"\n", + " TP = 0 # True Positives\n", + " FP = 0 # False Positives\n", + " FN = 0 # False Negatives\n", + "\n", + " # Loop over the validation dataset\n", + " for batch_images, batch_true_centers in val_dataset:\n", + " # Make predictions on the batch\n", + " predictions = model.predict(batch_images)\n", + " num_tiles = batch_images.shape[0]\n", + "\n", + " # Reshape predictions and true centers\n", + " predicted_centers = predictions.reshape(num_tiles, max_hits_per_tile, 2)\n", + " true_centers = batch_true_centers.numpy().reshape(num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # For each tile\n", + " for tile_idx in range(num_tiles):\n", + " pred_hits = predicted_centers[tile_idx]\n", + " true_hits = true_centers[tile_idx]\n", + "\n", + " # Remove padding (hits with coordinates (0, 0))\n", + " pred_hits = np.array([hit for hit in pred_hits if not np.allclose(hit, [0, 0])])\n", + " true_hits = np.array([hit for hit in true_hits if not np.allclose(hit, [0, 0])])\n", + "\n", + " if len(pred_hits) == 0 and len(true_hits) == 0:\n", + " continue # No hits to compare in this tile\n", + "\n", + " if len(pred_hits) == 0:\n", + " # All predicted hits are padding\n", + " FN += len(true_hits)\n", + " continue\n", + " if len(true_hits) == 0:\n", + " # All true hits are padding\n", + " FP += len(pred_hits)\n", + " continue\n", + "\n", + " # Compute cost matrix (distance matrix)\n", + " cost_matrix = np.linalg.norm(pred_hits[:, np.newaxis, :] - true_hits[np.newaxis, :, :], axis=2)\n", + "\n", + " # Apply threshold to cost matrix\n", + " cost_matrix[cost_matrix > distance_threshold] = np.inf\n", + "\n", + " # Check for NaN values in the cost matrix\n", + " if np.isnan(cost_matrix).any():\n", + " # Handle NaNs by setting them to infinity\n", + " cost_matrix = np.nan_to_num(cost_matrix, nan=np.inf)\n", + "\n", + " # Check if cost matrix is empty or contains only infinite values\n", + " if cost_matrix.size == 0 or np.isinf(cost_matrix).all():\n", + " # No feasible assignments\n", + " FP += len(pred_hits)\n", + " FN += len(true_hits)\n", + " continue\n", + "\n", + " try:\n", + " # Solve the assignment problem\n", + " row_ind, col_ind = linear_sum_assignment(cost_matrix)\n", + " except ValueError as e:\n", + " # Handle cases where the cost matrix is infeasible\n", + " FP += len(pred_hits)\n", + " FN += len(true_hits)\n", + " continue\n", + "\n", + " # Count matches\n", + " matches = 0\n", + " for i, j in zip(row_ind, col_ind):\n", + " if cost_matrix[i, j] != np.inf:\n", + " TP += 1\n", + " matches += 1\n", + " else:\n", + " # This shouldn't happen, but we'll account for it\n", + " pass\n", + "\n", + " # Count false positives and false negatives\n", + " FP += len(pred_hits) - matches\n", + " FN += len(true_hits) - matches\n", + "\n", + " # Compute precision, recall, and F1 score\n", + " precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + " recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + " f1_score = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0\n", + "\n", + " print(f\"True Positives: {TP}\")\n", + " print(f\"False Positives: {FP}\")\n", + " print(f\"False Negatives: {FN}\")\n", + " print(f\"Precision: {precision:.4f}\")\n", + " print(f\"Recall: {recall:.4f}\")\n", + " print(f\"F1 Score: {f1_score:.4f}\")\n", + "\n", + " return precision, recall, f1_score\n", + "\n", + "# Usage example:\n", + "\n", + "# Assuming you have your trained model, data_loader, and validation dataset\n", + "precision, recall, f1_score = compute_metrics(loaded_model, data_loader, val_dataset)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/256 by 256 Training MSE BCE.ipynb b/Computer Vision_Object Detection/256 by 256 Training MSE BCE.ipynb new file mode 100644 index 0000000..20c21ce --- /dev/null +++ b/Computer Vision_Object Detection/256 by 256 Training MSE BCE.ipynb @@ -0,0 +1,5038 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 15:32:44.191333: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-20 15:32:44.204893: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-20 15:32:44.217663: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-20 15:32:44.221552: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-20 15:32:44.233213: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-20 15:32:44.862877: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 15:32:45.868767: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def create_datasets(data_loader, train_size=0.9):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + " val_images_flat = val_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + "\n", + " # Flatten centers to match tiles\n", + " train_centers_flat = train_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + " val_centers_flat = val_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # Create TensorFlow datasets\n", + " batch_size = 10240*10\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/10KFixed_100_256by256_95indexNoNoise.h5'\n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 1., 166., 36.],\n", + " [ 1., 58., 162.],\n", + " [ 1., 108., 65.],\n", + " ...,\n", + " [ 1., 66., 248.],\n", + " [ 1., 23., 160.],\n", + " [ 1., 90., 173.]],\n", + "\n", + " [[ 1., 188., 24.],\n", + " [ 1., 235., 232.],\n", + " [ 1., 110., 231.],\n", + " ...,\n", + " [ 1., 80., 221.],\n", + " [ 1., 201., 226.],\n", + " [ 1., 150., 146.]],\n", + "\n", + " [[ 1., 93., 59.],\n", + " [ 1., 16., 6.],\n", + " [ 1., 150., 55.],\n", + " ...,\n", + " [ 1., 145., 69.],\n", + " [ 1., 106., 73.],\n", + " [ 1., 99., 199.]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1., 200., 26.],\n", + " [ 1., 91., 186.],\n", + " [ 1., 8., 189.],\n", + " ...,\n", + " [ 1., 249., 115.],\n", + " [ 1., 45., 188.],\n", + " [ 1., 238., 247.]],\n", + "\n", + " [[ 1., 149., 201.],\n", + " [ 1., 4., 212.],\n", + " [ 1., 183., 24.],\n", + " ...,\n", + " [ 1., 187., 238.],\n", + " [ 1., 171., 124.],\n", + " [ 1., 55., 15.]],\n", + "\n", + " [[ 1., 251., 220.],\n", + " [ 1., 96., 9.],\n", + " [ 1., 190., 219.],\n", + " ...,\n", + " [ 1., 71., 248.],\n", + " [ 1., 46., 166.],\n", + " [ 1., 213., 68.]]], dtype=float32)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "centers" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0.625, 0.125],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0.75 , 0.25 ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0.375],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0.625, 0.625],\n", + " [0. , 0. ]],\n", + "\n", + " [[0.5 , 0.625],\n", + " [0. , 0. ]],\n", + "\n", + " [[0.375, 0.625],\n", + " [0. , 0. ]],\n", + "\n", + " [[0.75 , 0.5 ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f= np.random.randint(0, 9)\n", + "train_centers[1][:100]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, 576)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "f= np.random.randint(0, 1024)\n", + "plt.imshow(train_images[0][f].reshape(8, 8)),f" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 0.],\n", + " [0., 0.]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers[0][f]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " \"\"\"\n", + " Create a model that predicts hit locations for individual tiles.\n", + " \n", + " Parameters:\n", + " - input_shape: shape of the input tile (e.g., (8, 8, 1)).\n", + " - max_hits: maximum number of hits per tile (e.g., 2).\n", + "\n", + " Returns:\n", + " - model: The Keras model.\n", + " \"\"\"\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional and pooling layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(512, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + "\n", + " # Final dense layer for predictions\n", + " outputs = layers.Dense(max_hits * 2,activation='sigmoid')(x)\n", + "\n", + " # Reshape output to match the target structure per tile\n", + " outputs = layers.Reshape((max_hits, 2))(outputs)\n", + "\n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def refined_detection_loss_with_padding(y_true, y_pred):\n", + "# \"\"\"\n", + "# Custom loss function accounting for:\n", + "# - Valid hits (ignoring padding (0, 0)).\n", + "# - Empty tiles (penalizing false positives).\n", + "# \"\"\"\n", + "# # Create masks\n", + "# valid_mask = tf.reduce_any(y_true != 0, axis=-1, keepdims=True) # Non-empty tiles\n", + "# padding_mask = tf.reduce_all(y_true == 0, axis=-1, keepdims=True) # Identify padding entries\n", + "\n", + "# # Cast boolean masks to float32\n", + "# valid_mask_float = tf.cast(valid_mask, dtype=y_true.dtype)\n", + "# padding_mask_float = tf.cast(padding_mask, dtype=y_true.dtype)\n", + "\n", + "# # ========================\n", + "# # Loss for Tiles with Hits\n", + "# # ========================\n", + "# # Exclude padding (0, 0) in valid tiles\n", + "# valid_loss = tf.square(y_true - y_pred) * valid_mask_float * (1 - padding_mask_float)\n", + "# mean_valid_loss = tf.reduce_sum(valid_loss) / (tf.reduce_sum(valid_mask_float * (1 - padding_mask_float)) + 1e-6)\n", + "\n", + "# # =============================\n", + "# # Loss for Empty Tiles (No Hits)\n", + "# # =============================\n", + "# # Compare predictions to (0, 0) for empty tiles\n", + "# empty_target = tf.zeros_like(y_true) # Ground truth for empty tiles is (0, 0)\n", + "# empty_loss = tf.square(y_pred - empty_target) * padding_mask_float\n", + "# mean_empty_loss = tf.reduce_sum(empty_loss) / (tf.reduce_sum(padding_mask_float) + 1e-6)\n", + "\n", + "# # ========================\n", + "# # Combine the Two Losses\n", + "# # ========================\n", + "# valid_weight = 1.0 # Weight for valid tiles\n", + "# no_object_weight = 3.0 # Weight for empty tiles\n", + "\n", + "# total_loss = valid_weight * mean_valid_loss + no_object_weight * mean_empty_loss\n", + "\n", + "# return total_loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def refined_mse_loss(y_true, y_pred):\n", + "# \"\"\"\n", + "# Custom loss function:\n", + "# - MSE for valid hits (ignoring padding (0, 0)).\n", + "# - Penalizes false positives and false negatives separately.\n", + "# \"\"\"\n", + "# # Create masks\n", + "# valid_mask = tf.reduce_any(y_true != 0, axis=-1, keepdims=True) # Non-empty tiles\n", + "# padding_mask = tf.reduce_all(y_true == 0, axis=-1, keepdims=True) # Identify padding entries\n", + "\n", + "# # Cast boolean masks to float32\n", + "# valid_mask_float = tf.cast(valid_mask, dtype=y_true.dtype)\n", + "# padding_mask_float = tf.cast(padding_mask, dtype=y_true.dtype)\n", + "\n", + "# # ========================\n", + "# # Loss for Tiles with Hits\n", + "# # ========================\n", + "# # MSE for valid hits, ignoring padding\n", + "# valid_loss = tf.square(y_true - y_pred) * valid_mask_float * (1 - padding_mask_float)\n", + "# mean_valid_loss = tf.reduce_sum(valid_loss) / (tf.reduce_sum(valid_mask_float * (1 - padding_mask_float)) + 1e-6)\n", + "\n", + "# # =============================\n", + "# # Penalize False Positives (Extra Predictions)\n", + "# # =============================\n", + "# # Penalize predictions far from (0, 0) in empty tiles\n", + "# empty_target = tf.zeros_like(y_true) # Ground truth for empty tiles is (0, 0)\n", + "# false_positive_loss = tf.square(y_pred - empty_target) * padding_mask_float\n", + "# mean_false_positive_loss = tf.reduce_sum(false_positive_loss) / (tf.reduce_sum(padding_mask_float) + 1e-6)\n", + "\n", + "# # =============================\n", + "# # Penalize False Negatives (Missed Hits)\n", + "# # =============================\n", + "# # Count missed hits (entries in y_true that are not predicted accurately)\n", + "# missed_hits_bool = tf.reduce_any(y_pred != 0, axis=-1, keepdims=True) # Boolean tensor\n", + "# missed_hits_mask = valid_mask_float * (1.0 - tf.cast(missed_hits_bool, dtype=y_true.dtype)) # Cast to float\n", + "# false_negative_loss = missed_hits_mask * 1.0 # Weight for false negatives\n", + "# mean_false_negative_loss = tf.reduce_sum(false_negative_loss) / (tf.reduce_sum(valid_mask_float) + 1e-6)\n", + "\n", + "# # ========================\n", + "# # Combine the Losses\n", + "# # ========================\n", + "# valid_weight = 1.0 # Weight for valid hits\n", + "# false_positive_weight = 3.0 # Penalize extra predictions more heavily\n", + "# false_negative_weight = 3.0 # Penalize missed hits\n", + "\n", + "# total_loss = (\n", + "# valid_weight * mean_valid_loss\n", + "# + false_positive_weight * mean_false_positive_loss\n", + "# + false_negative_weight * mean_false_negative_loss\n", + "# )\n", + "\n", + "# return total_loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def hungarian_loss_for_two_hits_vectorized(y_true, y_pred):\n", + " \"\"\"\n", + " Permutation-invariant loss for a tile with up to 2 hits, vectorized version.\n", + " \n", + " y_true, y_pred: (batch_size, 2, 2)\n", + " - y_true[i] has up to 2 hits, with zero-padding for empty slots.\n", + " - y_pred[i] is the model's 2 predicted points.\n", + " Returns: scalar (averaged loss across the batch).\n", + " \"\"\"\n", + "\n", + " # 1) Identify how many hits per tile\n", + " # row_nonzero[i,j] = True if y_true[i,j] != (0,0)\n", + " row_nonzero = tf.reduce_any(tf.not_equal(y_true, 0.0), axis=-1) # (batch_size, 2)\n", + " num_hits = tf.reduce_sum(tf.cast(row_nonzero, tf.float32), axis=-1) # (batch_size,), values ∈ {0,1,2}\n", + "\n", + " # 2) Create masks for 0-hit, 1-hit, 2-hit tiles\n", + " mask_0 = tf.equal(num_hits, 0.0) # (batch_size,)\n", + " mask_1 = tf.equal(num_hits, 1.0) # (batch_size,)\n", + " mask_2 = tf.equal(num_hits, 2.0) # (batch_size,)\n", + "\n", + " mask_0_f = tf.cast(mask_0, tf.float32)\n", + " mask_1_f = tf.cast(mask_1, tf.float32)\n", + " mask_2_f = tf.cast(mask_2, tf.float32)\n", + "\n", + " # -------------------------------------------------------------------------\n", + " # CASE 0 HITS: Force both predicted points to be (0,0).\n", + " # -------------------------------------------------------------------------\n", + " # cost0[i] = sum of squares of y_pred[i], i.e. (pred1^2 + pred2^2)\n", + " cost0 = tf.reduce_sum(tf.square(y_pred), axis=[1, 2]) # (batch_size,)\n", + "\n", + " # -------------------------------------------------------------------------\n", + " # CASE 2 HITS: Permutation-invariant cost.\n", + " # -------------------------------------------------------------------------\n", + " # cost_1 corresponds to (hit1→pred1, hit2→pred2)\n", + " dist_1_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 0, :]), axis=-1)\n", + " dist_1_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 1, :]), axis=-1)\n", + " cost_1 = dist_1_1 + dist_1_2\n", + "\n", + " # cost_2 corresponds to (hit1→pred2, hit2→pred1)\n", + " dist_2_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 1, :]), axis=-1)\n", + " dist_2_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 0, :]), axis=-1)\n", + " cost_2 = dist_2_1 + dist_2_2\n", + "\n", + " # Pick the smaller permutation cost\n", + " cost2 = tf.minimum(cost_1, cost_2) # (batch_size,)\n", + "\n", + " # -------------------------------------------------------------------------\n", + " # CASE 1 HIT:\n", + " # - Identify which row is the real hit (row0 or row1).\n", + " # - Compute MSE for matching that hit to whichever predicted row is closer.\n", + " # - Penalize the other predicted row for not being (0,0).\n", + " # -------------------------------------------------------------------------\n", + " row0_is_hit = row_nonzero[:, 0] # (batch_size,)\n", + " # ground-truth single hit => either tile_true[:,0,:] or tile_true[:,1,:]\n", + " gt_hit = tf.where(\n", + " tf.expand_dims(row0_is_hit, axis=-1),\n", + " y_true[:, 0, :],\n", + " y_true[:, 1, :]\n", + " ) # (batch_size, 2)\n", + "\n", + " # Distances to each predicted point\n", + " dist_pred_0 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 0, :]), axis=-1)\n", + " dist_pred_1 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 1, :]), axis=-1)\n", + "\n", + " # Also penalize the other row for not being near (0,0).\n", + " zero_cost_0 = tf.reduce_sum(tf.square(y_pred[:, 0, :]), axis=-1)\n", + " zero_cost_1 = tf.reduce_sum(tf.square(y_pred[:, 1, :]), axis=-1)\n", + "\n", + " # Two ways to match:\n", + " # -- pred_0 is the real hit => dist_pred_0 + zero_cost_1\n", + " # -- pred_1 is the real hit => dist_pred_1 + zero_cost_0\n", + " cost_if_0_matched = dist_pred_0 + zero_cost_1\n", + " cost_if_1_matched = dist_pred_1 + zero_cost_0\n", + " cost1 = tf.minimum(cost_if_0_matched, cost_if_1_matched) # (batch_size,)\n", + "\n", + " # -------------------------------------------------------------------------\n", + " # Combine costs across all tiles\n", + " # For each tile i, only one of mask_0, mask_1, mask_2 is True.\n", + " # -------------------------------------------------------------------------\n", + " total_cost = mask_0_f * cost0 + mask_1_f * cost1 + mask_2_f * cost2\n", + "\n", + " # Average over the batch\n", + " loss = tf.reduce_mean(total_cost)\n", + " return loss\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 512)      │       590,336 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 512)            │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │        65,664 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape (Reshape)               │ (None, 2, 2)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m590,336\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m65,664\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 657,796 (2.51 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m657,796\u001b[0m (2.51 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 657,796 (2.51 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m657,796\u001b[0m (2.51 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(optimizer = 'adam', loss=hungarian_loss_for_two_hits_vectorized)\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/60\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 15:35:53.628996: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1737405353.693496 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.727603 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.729570 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.740472 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.745067 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.785783 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.799930 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.800058 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.808123 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.830827 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.835568 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.840355 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.846788 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.852999 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.860742 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.868830 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.874188 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.886840 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.902792 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.917257 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.927890 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405353.942080 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.460408 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.463424 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.465369 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.469168 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.471479 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.478353 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.480543 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.482809 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.487424 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.490253 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.492761 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.495637 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.498425 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.501421 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.505466 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.509258 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.513085 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.517676 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405354.631147 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.050019 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.067590 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.077822 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.086062 314987 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.583399 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.594390 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.605388 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.616897 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.628437 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.641312 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.653412 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.662189 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.674878 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.685919 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.698795 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.707203 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.722450 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.737071 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.752168 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.768517 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.786798 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.797954 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.818530 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.845807 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405355.868300 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.268685 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.339008 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.346000 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.351580 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.358178 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.363467 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.370351 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.376113 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.382119 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.387725 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.397794 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.403367 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.409782 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.416129 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/90\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m6:21\u001b[0m 4s/step - loss: 0.9678" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737405356.469578 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.475603 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.484195 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.492349 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.500486 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.508570 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.517910 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.522295 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.522349 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.565646 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405356.579689 314984 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 145ms/step - loss: 0.3467" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 15:36:09.430557: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2025-01-20 15:36:09.430720: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1737405370.027059 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.029554 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.031932 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.034494 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.036684 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.039009 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.041766 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.044226 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.047861 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.051146 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.054037 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.057091 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.061054 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.064747 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.068769 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.072458 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.077629 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.080629 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.083938 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.087759 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.098209 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.101619 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.120007 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.125101 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.127542 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.147041 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.156249 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.161050 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.165026 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.170011 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.176865 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.189609 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.194879 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.199093 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.210095 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737405370.227572 314982 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 166ms/step - loss: 0.3444 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 2/60\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 15:36:11.314326: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 77ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 3/60\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 15:36:20.021645: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 108ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 4/60\n", + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 77ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 5/60\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 15:36:36.903237: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 77ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 6/60\n", + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 77ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 7/60\n", + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 77ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 8/60\n", + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 90ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 9/60\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 15:37:06.234670: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 79ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 10/60\n", + "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 77ms/step - loss: 0.0536 - val_loss: 0.0535 - learning_rate: 0.0010\n", + "Epoch 11/60\n", + "\u001b[1m11/90\u001b[0m \u001b[32m━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m6s\u001b[0m 89ms/step - loss: 0.0537" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m60\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mlr_scheduler\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/keras/src/utils/traceback_utils.py:117\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 115\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 117\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 118\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 119\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/keras/src/backend/tensorflow/trainer.py:318\u001b[0m, in \u001b[0;36mTensorFlowTrainer.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq)\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m step, iterator \u001b[38;5;129;01min\u001b[39;00m epoch_iterator\u001b[38;5;241m.\u001b[39menumerate_epoch():\n\u001b[1;32m 317\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m--> 318\u001b[0m logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 319\u001b[0m logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pythonify_logs(logs)\n\u001b[1;32m 320\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_end(step, logs)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:833\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 830\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 832\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 833\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 835\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 836\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:878\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 875\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[1;32m 876\u001b[0m \u001b[38;5;66;03m# In this case we have not created variables on the first call. So we can\u001b[39;00m\n\u001b[1;32m 877\u001b[0m \u001b[38;5;66;03m# run the first trace but we should fail if variables are created.\u001b[39;00m\n\u001b[0;32m--> 878\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 879\u001b[0m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_variable_creation_config\u001b[49m\n\u001b[1;32m 880\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 881\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_created_variables:\n\u001b[1;32m 882\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCreating variables on a non-first call to a function\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 883\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m decorated with tf.function.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[0;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[1;32m 137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[0;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[1;32m 140\u001b[0m \u001b[43m \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[1;32m 141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py:1322\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[1;32m 1318\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1319\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1320\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1321\u001b[0m \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1322\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1323\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1324\u001b[0m args,\n\u001b[1;32m 1325\u001b[0m possible_gradient_type,\n\u001b[1;32m 1326\u001b[0m executing_eagerly)\n\u001b[1;32m 1327\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m 214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m 215\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 216\u001b[0m flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 217\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[1;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[0;32m--> 251\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 252\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 253\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 257\u001b[0m outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[1;32m 258\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 259\u001b[0m \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[1;32m 260\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[1;32m 261\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/context.py:1552\u001b[0m, in \u001b[0;36mContext.call_function\u001b[0;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[1;32m 1550\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[1;32m 1551\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1552\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1553\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1554\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1555\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1556\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1557\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1558\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1559\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1560\u001b[0m outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 1561\u001b[0m name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 1562\u001b[0m num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1566\u001b[0m cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[1;32m 1567\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 52\u001b[0m ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 53\u001b[0m tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=60,\n", + " \n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/50KFixed_100_256by256_RandomindexwithNoise_linear_custom_HungarianLoss.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/10KFixed_100_256by256_RandomindexWithNoise_linear_separatelosses.keras')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m256/256\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 612us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1736970010.912732 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.913117 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.913355 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.913555 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.913762 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.913976 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.914190 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.914401 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.914608 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.914814 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.915035 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.915250 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.915476 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.915698 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.915920 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.916124 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.916341 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.916568 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.916804 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.917031 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.917267 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.917704 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736970010.917940 411441 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted centers shape: (8, 1024, 2, 2)\n", + "Grouped targets shape: (8, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "# # # # Flatten validation images and centers\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "\n", + "# Batch size for n images\n", + "batch = 8* 1024 # number of images per batch\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch)\n", + "# Make predictions on dataset\n", + "# inputs, targets = next(iter(val_dataset)) # Extract a batch\n", + "inputs, targets = next(iter(train_dataset)) # Extract a batch\n", + "outputs = model.predict(inputs)\n", + "\n", + "# Reshape predictions and targets back to image structure\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 2)\n", + "\n", + "# Print the shapes\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\") # (batch_size // 1024, 1024, 2, 2)\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\") # (batch_size // 1024, 1024, 2, 2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train_centers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 6:\n", + "Tile 0: Predicted: [[ 0.00558282 0.00213352]\n", + " [-0.00751558 0.00076738]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: Predicted: [[ 3.0781096e-04 -1.4598720e-04]\n", + " [ 7.9460442e-05 -1.1293292e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[ 0.00012557 -0.00108062]\n", + " [ 0.00073252 -0.00052118]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[-3.0065514e-04 -7.2074757e-04]\n", + " [-9.3393028e-05 3.8212165e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 4: Predicted: [[ 0.00015937 -0.00058929]\n", + " [-0.00026817 0.00030878]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 5: Predicted: [[-0.00678132 -0.00427026]\n", + " [ 0.7610104 0.22537687]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 6: Predicted: [[-0.00014753 -0.00105508]\n", + " [-0.00042496 -0.00051688]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 7: Predicted: [[-8.8446308e-05 -5.7298836e-04]\n", + " [-2.2854656e-04 -1.1102408e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[-4.8386399e-05 -8.4446516e-04]\n", + " [-1.4003366e-03 -6.7210943e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[ 0.00064137 -0.000734 ]\n", + " [-0.00021427 0.00055366]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[ 0.00051684 -0.00059604]\n", + " [-0.00068688 -0.00086374]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 11: Predicted: [[ 0.00036128 -0.00082724]\n", + " [ 0.00073273 -0.00175028]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[-0.00020869 -0.00095275]\n", + " [ 0.00018453 -0.00130531]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[ 1.1761719e-04 9.1905182e-05]\n", + " [-6.0264766e-04 -8.9122355e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[ 0.00030564 -0.00041454]\n", + " [-0.00036225 -0.00134063]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[ 0.00036364 -0.00077903]\n", + " [-0.00051114 -0.00049181]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[ 0.0006598 -0.0001681 ]\n", + " [-0.00011478 -0.00110921]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[ 0.00048347 -0.00010855]\n", + " [-0.00094324 -0.00194012]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 18: Predicted: [[ 0.00036634 -0.00085872]\n", + " [ 0.00015505 -0.00077144]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[ 0.00017477 -0.00064796]\n", + " [-0.00041474 -0.00135639]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[ 0.00011831 -0.00080866]\n", + " [-0.00044005 -0.00100397]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[ 0.00014667 -0.0008977 ]\n", + " [ 0.00019682 -0.00157885]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[-0.00514974 0.00268412]\n", + " [ 0.12057319 0.7550868 ]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 23: Predicted: [[ 0.00040624 -0.00082943]\n", + " [-0.00041132 -0.00166438]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 24: Predicted: [[-0.00010648 -0.0003749 ]\n", + " [ 0.00031621 -0.00092936]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[-0.0008073 -0.00139674]\n", + " [ 0.00160618 -0.00040919]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[ 0.00020075 -0.00071695]\n", + " [ 0.00023785 -0.00090015]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[ 4.0716887e-04 -9.0884248e-04]\n", + " [-4.3556094e-05 -1.3672486e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 28: Predicted: [[ 7.5071678e-04 -6.1192778e-03]\n", + " [ 1.1364618e-01 7.6906604e-01]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 29: Predicted: [[ 0.00029428 -0.00078255]\n", + " [ 0.00030085 -0.00155744]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 30: Predicted: [[ 0.00026467 -0.00078228]\n", + " [-0.00047375 -0.00073726]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 31: Predicted: [[ 0.00025809 -0.00061685]\n", + " [-0.00039653 -0.00096 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[-0.00020279 -0.00096589]\n", + " [ 0.00048149 -0.0005229 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[ 6.8537891e-05 -6.7566225e-04]\n", + " [-1.3692006e-03 -2.6461035e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 34: Predicted: [[-0.00014679 -0.00104022]\n", + " [ 0.0009662 -0.00050623]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 35: Predicted: [[ 0.00019764 -0.00055808]\n", + " [ 0.00011839 0.00019401]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[ 0.00022855 -0.00047986]\n", + " [ 0.00010126 -0.00052753]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 37: Predicted: [[-0.00014981 -0.00126689]\n", + " [ 0.00235215 0.00194411]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 38: Predicted: [[ 0.00037869 -0.00090177]\n", + " [ 0.00053199 -0.00042294]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[-5.9751794e-04 -1.7874973e-04]\n", + " [ 4.0909648e-04 5.9679151e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[ 0.00026594 -0.0009244 ]\n", + " [-0.00069106 -0.00047816]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[-9.5673371e-05 -6.2123832e-04]\n", + " [ 3.6815554e-04 -6.2017143e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[ 8.8234432e-05 -6.0171733e-04]\n", + " [ 1.4335588e-03 -5.6288391e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[-5.7274010e-05 -6.1769603e-04]\n", + " [-7.6649338e-04 -1.7165542e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 44: Predicted: [[ 0.00037062 -0.00037453]\n", + " [-0.00033822 -0.00173152]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[ 0.00034906 -0.00061357]\n", + " [-0.00038241 -0.00142962]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 46: Predicted: [[ 0.00054652 -0.00039242]\n", + " [-0.00011602 -0.00094518]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[ 0.00054848 -0.00058386]\n", + " [-0.00059259 -0.0015852 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 48: Predicted: [[ 2.8386689e-04 -7.7472645e-04]\n", + " [-6.7077577e-05 -8.4780157e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 49: Predicted: [[ 0.00032686 -0.00044952]\n", + " [-0.00031982 -0.00140594]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[ 0.0001021 -0.0008222 ]\n", + " [ 0.00064095 -0.00028273]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 51: Predicted: [[ 9.2040747e-05 -9.1444346e-04]\n", + " [-1.4644116e-04 -1.5851185e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[4.2251330e-03 1.8369633e-04]\n", + " [8.3909976e-01 2.4152625e-01]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 53: Predicted: [[-7.415004e-05 -7.758949e-04]\n", + " [ 3.850907e-04 -9.331852e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[-8.6763874e-05 -6.6567940e-04]\n", + " [ 1.5525520e-04 -9.9332631e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 55: Predicted: [[ 0.00063022 -0.00048749]\n", + " [ 0.00068761 -0.00065397]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[ 4.4878782e-04 8.3800120e-04]\n", + " [-4.8428774e-05 -1.6699731e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[-8.4554777e-06 -1.1340394e-03]\n", + " [ 3.8788468e-04 -1.3153777e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[-0.00021189 -0.0007122 ]\n", + " [ 0.00031121 -0.00046545]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 59: Predicted: [[ 0.00025289 -0.00067727]\n", + " [ 0.00011986 -0.00112891]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[ 0.00047772 -0.00033748]\n", + " [-0.00074419 -0.00064569]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 61: Predicted: [[-6.7606568e-05 -3.8263208e-04]\n", + " [-6.0354918e-04 -7.5712800e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[ 0.00037179 -0.00061539]\n", + " [-0.00025699 -0.00091361]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 63: Predicted: [[ 0.0003161 -0.00085196]\n", + " [-0.00020063 -0.00097127]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 64: Predicted: [[-4.2842701e-05 -7.3618075e-04]\n", + " [ 9.8254532e-04 -2.0985603e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 65: Predicted: [[-0.00333636 -0.00582916]\n", + " [-0.04205868 -0.03963432]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 66: Predicted: [[ 9.9828467e-05 -1.0079390e-03]\n", + " [ 7.3930621e-04 -5.7899207e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 67: Predicted: [[-7.0476439e-05 -1.0606081e-03]\n", + " [ 1.2531132e-04 -7.6055527e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 68: Predicted: [[ 2.9923790e-04 -1.9921572e-06]\n", + " [-1.4320835e-03 -1.4244989e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 69: Predicted: [[ 0.00022858 -0.00057485]\n", + " [-0.0003191 -0.00136576]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[-3.0778348e-05 -4.4018921e-04]\n", + " [-9.9473447e-04 -7.6539814e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 71: Predicted: [[ 0.00042792 -0.00096177]\n", + " [-0.0006627 -0.00101379]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[-0.00014884 -0.00106455]\n", + " [ 0.00028107 -0.00030056]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 73: Predicted: [[-0.0001135 -0.00105501]\n", + " [ 0.0007043 -0.00029568]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[ 0.00020782 -0.0003345 ]\n", + " [ 0.00054423 -0.00077073]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[-0.00010696 -0.00064694]\n", + " [ 0.00137266 -0.00102594]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 76: Predicted: [[ 0.00229856 -0.00080885]\n", + " [ 0.45563948 0.0077237 ]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 77: Predicted: [[ 0.0003841 -0.00054346]\n", + " [ 0.00047094 -0.00074296]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[ 1.0592071e-03 -5.7422149e-05]\n", + " [-3.2830983e-04 -1.2539923e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[ 0.00016023 -0.00069546]\n", + " [ 0.00011249 -0.00112993]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 80: Predicted: [[ 0.00067157 -0.00045927]\n", + " [-0.0006927 -0.0022285 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[ 2.2074208e-05 -6.6969631e-04]\n", + " [ 2.5582314e-04 -1.2821704e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[ 0.00022117 -0.00067329]\n", + " [-0.00032479 -0.00083504]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[ 1.3469718e-05 -3.5396271e-04]\n", + " [-5.2079558e-05 -7.7603012e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[-0.0014067 -0.00083091]\n", + " [ 0.6190245 0.55375654]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 85: Predicted: [[ 0.00050152 -0.00068431]\n", + " [-0.00017764 -0.00131663]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 86: Predicted: [[ 2.7263630e-04 -5.7079579e-04]\n", + " [-3.4280121e-05 -1.6106367e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 87: Predicted: [[ 0.00022243 -0.00077839]\n", + " [-0.00054874 -0.00170086]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 88: Predicted: [[ 0.00018911 -0.0005183 ]\n", + " [-0.00038952 -0.00119852]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[ 0.00043041 -0.00105461]\n", + " [-0.0002177 -0.00108603]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 90: Predicted: [[-0.00736674 -0.00876551]\n", + " [ 0.38195074 0.6620545 ]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 91: Predicted: [[-4.82769683e-05 -7.93141720e-04]\n", + " [ 1.05813146e-04 -4.74765897e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 92: Predicted: [[ 3.1201798e-04 -4.6914263e-04]\n", + " [ 6.5714121e-06 -1.2686849e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 93: Predicted: [[ 0.00030067 -0.00079735]\n", + " [ 0.00101648 -0.0012489 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[ 3.3156481e-04 -7.2138564e-04]\n", + " [ 2.9484183e-04 -4.1708350e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 95: Predicted: [[ 4.4364017e-05 -7.5831410e-04]\n", + " [ 3.2745302e-05 -2.1839514e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 96: Predicted: [[ 5.4500997e-05 -4.9912051e-04]\n", + " [ 1.3942271e-04 -1.1257902e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[-0.00018859 -0.00102788]\n", + " [ 0.00269767 -0.00053685]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 98: Predicted: [[ 2.1904707e-06 -8.8616722e-04]\n", + " [ 1.9916221e-03 -1.6054139e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 99: Predicted: [[-0.00516482 -0.00157095]\n", + " [ 0.5012249 0.2508745 ]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 100: Predicted: [[ 0.00039982 -0.00037074]\n", + " [-0.00047173 -0.00042869]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[-0.00022081 -0.00030803]\n", + " [-0.00020982 -0.00143912]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 102: Predicted: [[-0.00019837 -0.00066706]\n", + " [-0.00059164 -0.00072548]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 103: Predicted: [[ 0.00011013 -0.00076647]\n", + " [ 0.00056951 -0.00141785]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[-4.3923035e-05 -8.9984445e-05]\n", + " [ 2.1354854e-04 -6.5194815e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[ 0.0002848 -0.00069728]\n", + " [-0.00040977 -0.00126199]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 106: Predicted: [[ 0.0006082 -0.00052363]\n", + " [-0.00035086 -0.00133393]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[-0.00032676 -0.00087753]\n", + " [ 0.0008728 -0.00137638]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 108: Predicted: [[ 0.00043568 -0.00068167]\n", + " [ 0.00012517 -0.0007647 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[-1.6249949e-04 -1.0737507e-03]\n", + " [-1.9580126e-05 -8.6408108e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[ 0.0003273 -0.00073888]\n", + " [-0.00066172 -0.00097961]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 111: Predicted: [[ 0.00027887 -0.00057924]\n", + " [ 0.00045407 -0.00064268]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 112: Predicted: [[-0.00422452 -0.00231218]\n", + " [ 0.70620716 0.3876389 ]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 113: Predicted: [[ 0.00011113 -0.00113152]\n", + " [ 0.00056962 -0.00107821]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 114: Predicted: [[ 0.00050963 -0.00078978]\n", + " [-0.00046354 -0.0012693 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[ 0.00015786 -0.00052227]\n", + " [-0.00051273 -0.00120613]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[ 2.5554094e-05 -7.1978284e-04]\n", + " [-6.1892718e-04 -1.8392429e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[ 0.00059678 -0.00051019]\n", + " [-0.00095909 -0.00222826]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 118: Predicted: [[ 0.00033008 -0.00085145]\n", + " [-0.00029831 -0.00019541]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 119: Predicted: [[ 0.00022681 -0.00031956]\n", + " [-0.00116538 -0.00172575]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 120: Predicted: [[ 3.2968353e-05 -7.4506371e-04]\n", + " [ 3.0586869e-04 -5.2772462e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[-0.00011791 -0.00102246]\n", + " [ 0.00011721 -0.00132838]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 122: Predicted: [[0.12868069 0.06482551]\n", + " [0.40023658 0.18430081]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[-6.172992e-05 -9.739763e-04]\n", + " [ 4.393980e-04 -6.546378e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 124: Predicted: [[ 0.00011634 -0.00052014]\n", + " [-0.00013523 -0.000622 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[ 4.7700852e-04 -6.6095259e-04]\n", + " [-9.8399818e-05 -1.1312887e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 126: Predicted: [[-0.00018827 -0.00094315]\n", + " [-0.00065953 -0.00132124]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 127: Predicted: [[ 3.2971939e-04 -3.8951926e-05]\n", + " [ 6.3106418e-05 -2.9377639e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[ 2.5659660e-04 -5.9805653e-04]\n", + " [-6.1973929e-05 -9.9337846e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 129: Predicted: [[ 1.0703690e-05 -4.0432630e-04]\n", + " [ 8.6341053e-04 -4.8007816e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[-0.00017924 -0.00116266]\n", + " [ 0.00058208 -0.0010716 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 131: Predicted: [[ 0.00035466 -0.00049331]\n", + " [-0.00057673 -0.00138351]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[ 0.00010706 -0.00073867]\n", + " [-0.0004674 -0.00066049]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[-5.4727308e-05 -8.0393482e-04]\n", + " [ 7.5063109e-04 -1.1217073e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 134: Predicted: [[ 0.00028342 -0.00043054]\n", + " [-0.00015324 -0.00064292]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[ 0.00063867 -0.00104893]\n", + " [ 0.00350863 -0.00178534]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[-0.00049245 -0.00035249]\n", + " [-0.00124061 -0.00224764]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[ 0.00032951 -0.00056132]\n", + " [-0.00044782 -0.00058479]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[-2.2851350e-04 -1.3895517e-03]\n", + " [ 9.3850493e-04 -9.9271536e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[ 0.00067491 -0.00031379]\n", + " [-0.00018574 -0.0005752 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 140: Predicted: [[ 0.0003276 -0.0005596 ]\n", + " [-0.0002951 -0.00207632]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 141: Predicted: [[-0.0058351 -0.00424131]\n", + " [ 0.35625395 0.6353627 ]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 142: Predicted: [[ 1.9443128e-04 -5.8941246e-04]\n", + " [ 1.6920269e-05 1.4983118e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 143: Predicted: [[ 0.0002875 -0.00048996]\n", + " [-0.00028452 -0.00085803]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[-0.00223596 0.00316156]\n", + " [ 0.6212127 0.01185134]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 145: Predicted: [[ 0.00030273 -0.00055636]\n", + " [ 0.00037546 -0.00126559]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[0.00607985 0.00230864]\n", + " [0.71175766 0.57319486]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 147: Predicted: [[-3.0846056e-04 -6.4995588e-04]\n", + " [ 5.4821372e-05 -1.8465370e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[ 0.00016675 -0.00063792]\n", + " [-0.00013893 -0.00088356]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 149: Predicted: [[ 7.5126998e-05 -6.1296910e-04]\n", + " [-1.1648387e-03 -2.3179129e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[ 0.00072333 -0.00075615]\n", + " [-0.00027221 -0.0017658 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 151: Predicted: [[ 0.00040377 -0.00039379]\n", + " [-0.00016563 -0.00183897]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[-3.2439362e-05 -8.7818567e-04]\n", + " [-5.7215989e-04 -1.2260005e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[ 0.00018667 -0.00082793]\n", + " [ 0.0003426 -0.00083163]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[ 0.00052185 -0.00067135]\n", + " [ 0.00033294 -0.0005637 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 155: Predicted: [[ 5.0408719e-04 -3.5137573e-04]\n", + " [ 1.8335879e-05 -9.6475333e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[ 3.3511780e-04 -6.6948455e-04]\n", + " [-1.5005469e-05 -8.3871186e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[ 0.00015491 -0.00082483]\n", + " [-0.00028712 -0.00081225]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[ 0.00017793 -0.0007843 ]\n", + " [-0.0003895 -0.0005163 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[ 0.00054934 -0.00053877]\n", + " [-0.00114964 -0.00082117]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 160: Predicted: [[-0.00696534 0.00107038]\n", + " [ 0.5881671 0.02565776]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 161: Predicted: [[ 0.00056036 -0.00027024]\n", + " [ 0.00047059 -0.00201713]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 162: Predicted: [[ 0.00083875 -0.00039063]\n", + " [-0.00098564 -0.00124858]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[ 0.00018746 -0.00071523]\n", + " [ 0.00018448 -0.00194787]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 164: Predicted: [[-0.00011263 -0.00076975]\n", + " [ 0.00097536 -0.00110038]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 165: Predicted: [[ 2.8303103e-04 -8.7341265e-04]\n", + " [ 9.5367432e-06 1.6213208e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 166: Predicted: [[ 0.00063191 -0.00049623]\n", + " [-0.00067315 -0.00177969]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 167: Predicted: [[-0.00020534 -0.00048019]\n", + " [-0.0005726 -0.00080715]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[-0.00020979 -0.00048418]\n", + " [-0.00048291 -0.00067084]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 169: Predicted: [[ 0.00022118 -0.00059427]\n", + " [-0.00020836 -0.0014926 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[-0.00136331 -0.00273047]\n", + " [ 0.6014819 0.23857298]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 171: Predicted: [[ 0.0003333 -0.00078766]\n", + " [ 0.0005119 -0.00031176]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 172: Predicted: [[ 0.00028921 -0.0006305 ]\n", + " [-0.00033773 -0.00137144]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[ 3.5124365e-05 -9.4837713e-04]\n", + " [ 2.7699023e-04 -1.1384338e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 174: Predicted: [[ 0.00014842 -0.00062401]\n", + " [-0.00053167 -0.00064205]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[ 0.00412589 -0.00040257]\n", + " [ 0.05042333 0.06483634]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[ 7.8424346e-05 -2.1778146e-04]\n", + " [ 2.7470291e-05 -1.8716231e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[ 0.00023898 -0.00071027]\n", + " [-0.00025152 -0.00079366]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[ 1.6922783e-04 -7.4507162e-04]\n", + " [ 7.8774989e-05 -4.0242076e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 179: Predicted: [[ 0.000204 -0.00059726]\n", + " [-0.00030095 -0.00085318]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 180: Predicted: [[ 2.8387760e-04 -9.0820523e-04]\n", + " [-5.3346157e-05 -5.0944835e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[ 0.00024016 -0.00066078]\n", + " [-0.00031113 -0.00110786]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 182: Predicted: [[ 0.00027607 -0.00065902]\n", + " [-0.00015675 -0.00033283]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[ 0.00013302 -0.0006253 ]\n", + " [-0.00072101 -0.00101074]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 184: Predicted: [[-0.00024416 -0.00093943]\n", + " [ 0.00042554 -0.00119174]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[-0.00017401 -0.00091407]\n", + " [ 0.00124752 -0.0005244 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 186: Predicted: [[ 0.00054066 -0.00057763]\n", + " [-0.00028919 -0.00122045]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[ 0.00036211 -0.00038486]\n", + " [-0.00074005 -0.0006822 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 188: Predicted: [[ 0.00037185 -0.00075238]\n", + " [-0.00039669 -0.00103401]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[ 0.00017986 -0.00058889]\n", + " [ 0.00014918 -0.00058632]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 190: Predicted: [[ 0.00014105 -0.00034136]\n", + " [-0.00064164 -0.00193677]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[ 0.00027752 -0.0007338 ]\n", + " [ 0.00034562 -0.0005577 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 192: Predicted: [[ 0.00057736 -0.00041755]\n", + " [ 0.00012644 -0.00270175]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[ 0.00038388 -0.00076129]\n", + " [ 0.00021661 -0.00082182]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 194: Predicted: [[ 0.00017802 -0.00074532]\n", + " [ 0.00045168 -0.00075053]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[-7.91591592e-05 -1.10879121e-03]\n", + " [ 1.09143555e-04 -8.28057528e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 196: Predicted: [[ 7.2997063e-06 -8.1417925e-04]\n", + " [-1.8618256e-04 -5.3348392e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[ 0.00031117 -0.00061263]\n", + " [-0.00025326 -0.00099245]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 198: Predicted: [[ 0.00046815 -0.00061769]\n", + " [-0.00025086 -0.00054288]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 199: Predicted: [[ 0.00014739 -0.00029431]\n", + " [-0.00072952 -0.000941 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[-5.5099372e-05 -5.7711342e-04]\n", + " [ 8.1845373e-04 -3.9768219e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 201: Predicted: [[-0.00020982 -0.00073044]\n", + " [ 0.00264446 -0.00027831]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 202: Predicted: [[ 2.5570323e-04 -8.0599933e-04]\n", + " [ 9.5307827e-05 1.3143569e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[0.00099313 0.00103995]\n", + " [0.34152803 0.34747183]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[ 0.0003407 -0.00086506]\n", + " [-0.00062273 -0.00107155]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 205: Predicted: [[-3.6394782e-04 2.0176399e-04]\n", + " [ 5.1319748e-01 4.5340583e-03]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 206: Predicted: [[ 0.0030548 -0.00333803]\n", + " [ 0.34372106 0.51893854]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 207: Predicted: [[ 3.5622204e-04 -6.8695418e-04]\n", + " [-4.0337443e-05 -8.6425990e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[ 0.00030412 -0.00066739]\n", + " [-0.00011046 -0.0011543 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[-1.2536906e-04 9.9522723e-03]\n", + " [ 2.5243673e-01 6.3113928e-01]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 210: Predicted: [[ 0.0001443 -0.00068891]\n", + " [-0.00107928 -0.00179791]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 211: Predicted: [[ 0.00019938 -0.00079262]\n", + " [-0.00032903 -0.00120658]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 212: Predicted: [[ 0.00039856 -0.00057981]\n", + " [-0.00047624 -0.000616 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 213: Predicted: [[ 0.00040579 -0.00038794]\n", + " [-0.00064926 -0.00139626]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 214: Predicted: [[ 3.3390243e-05 -7.5807533e-04]\n", + " [-7.8707933e-05 -9.5134228e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 215: Predicted: [[2.0407885e-04 1.0178354e-02]\n", + " [5.9407270e-01 7.4252790e-01]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 216: Predicted: [[1.9940222e-04 6.6039094e-05]\n", + " [9.2080235e-04 1.9621104e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 217: Predicted: [[ 0.00030292 -0.00080281]\n", + " [-0.00055937 -0.0009783 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 218: Predicted: [[ 2.1851081e-03 -5.2546110e-04]\n", + " [ 7.5928092e-01 5.3785479e-01]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 219: Predicted: [[ 9.4259158e-05 -7.8322488e-04]\n", + " [ 1.3311207e-04 -1.1406764e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 220: Predicted: [[ 5.7658181e-05 -9.2997967e-04]\n", + " [-2.5703758e-04 -1.0042861e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[ 0.00046281 -0.00026484]\n", + " [ 0.0003932 -0.00070886]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 222: Predicted: [[ 0.00028089 -0.00093722]\n", + " [ 0.00037162 -0.00052273]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[ 1.4272751e-04 -9.3419215e-04]\n", + " [ 7.0929527e-05 -3.3862889e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[-0.00023791 -0.00097567]\n", + " [ 0.0014315 0.00042804]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 225: Predicted: [[ 0.000434 -0.0006598 ]\n", + " [ 0.00019302 -0.00078331]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 226: Predicted: [[-0.00784564 -0.00317579]\n", + " [ 0.37361458 0.7501289 ]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 227: Predicted: [[ 0.00023782 -0.00058412]\n", + " [-0.00073206 -0.00130014]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 228: Predicted: [[ 0.00023554 -0.00060155]\n", + " [-0.00022078 -0.00158938]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[ 2.8877053e-05 -9.3323278e-04]\n", + " [ 2.7620047e-04 -1.1687428e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 230: Predicted: [[ 0.00053525 -0.00047042]\n", + " [-0.00077109 -0.00101377]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 231: Predicted: [[ 0.00013018 -0.00019397]\n", + " [ 0.00048405 -0.0019637 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[-1.7705373e-05 -5.3655740e-04]\n", + " [-1.0410845e-03 -1.2965053e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[-6.4194202e-05 -9.5888093e-04]\n", + " [ 7.1437657e-04 -1.1388659e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 234: Predicted: [[ 0.00033077 -0.00071309]\n", + " [ 0.00082608 -0.00057342]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[ 2.1903776e-04 1.4324789e-03]\n", + " [ 5.5670977e-01 -3.0894056e-03]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 236: Predicted: [[ 0.00026339 -0.00050782]\n", + " [-0.00055439 -0.00135761]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 237: Predicted: [[ 0.00102407 -0.00052047]\n", + " [-0.00080624 -0.00152776]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 238: Predicted: [[-0.00172998 -0.00472816]\n", + " [ 0.37540942 -0.00539414]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 239: Predicted: [[ 1.04049686e-04 -7.58511771e-04]\n", + " [-4.77135181e-05 -5.38453460e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 240: Predicted: [[ 0.00049922 -0.00050187]\n", + " [-0.0006287 -0.00098395]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 241: Predicted: [[ 0.00049198 -0.00083237]\n", + " [ 0.0003418 -0.00093188]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 242: Predicted: [[ 7.8205019e-05 -5.0694362e-04]\n", + " [-1.7704815e-04 -9.6078962e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[ 9.4901770e-06 -9.8087592e-04]\n", + " [-4.3842942e-04 -1.0242313e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 244: Predicted: [[ 0.00064774 -0.00034888]\n", + " [-0.00144254 -0.00178628]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 245: Predicted: [[-0.00349179 -0.00618898]\n", + " [ 0.50384545 0.6362115 ]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 246: Predicted: [[-2.4179462e-05 -5.1619037e-04]\n", + " [ 8.2278252e-04 -1.2839437e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 247: Predicted: [[ 1.6734004e-04 -9.1481494e-04]\n", + " [-6.4462423e-05 -1.8906146e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[ 0.00061921 -0.00061133]\n", + " [-0.00024235 -0.00091367]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 249: Predicted: [[ 0.00033762 -0.00073752]\n", + " [-0.0003803 -0.0007688 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[ 0.00015458 -0.00081623]\n", + " [ 0.00014837 -0.00105123]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[ 0.0004601 -0.00064036]\n", + " [-0.00093456 -0.00057645]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[-0.00197448 -0.00478762]\n", + " [ 0.51460516 0.00941981]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 253: Predicted: [[ 3.8591633e-04 -3.5999430e-04]\n", + " [-9.6783042e-06 -2.0310581e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 254: Predicted: [[-0.00417461 -0.00198642]\n", + " [ 0.613884 0.7810975 ]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 255: Predicted: [[-1.7482368e-04 -7.1041816e-04]\n", + " [ 1.6502142e-03 -5.7674944e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[ 0.00057726 0.00079962]\n", + " [-0.00407538 -0.00299829]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 257: Predicted: [[ 0.00075484 -0.00061793]\n", + " [-0.00015169 -0.00155106]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 258: Predicted: [[-0.0007553 -0.00093713]\n", + " [ 0.0017085 0.00016471]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 259: Predicted: [[-8.2748942e-05 -4.8100442e-04]\n", + " [-2.5089830e-04 -1.5553981e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[ 0.00020823 -0.00073768]\n", + " [-0.00015037 -0.00158492]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[ 0.00445898 -0.0021429 ]\n", + " [ 0.34931523 0.40161514]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 262: Predicted: [[ 0.00025099 -0.00080815]\n", + " [ 0.00010924 -0.00095603]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[-0.00012456 -0.00091288]\n", + " [ 0.00042537 -0.00035767]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 264: Predicted: [[ 0.00069231 -0.00012357]\n", + " [ 0.00029507 -0.00130893]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[ 0.00018327 -0.00082182]\n", + " [-0.00097406 -0.00165777]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 266: Predicted: [[ 0.00029494 -0.00076432]\n", + " [ 0.00193128 -0.00114605]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 267: Predicted: [[-3.8344413e-05 -6.9155201e-04]\n", + " [-3.3656508e-04 -1.5247017e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 268: Predicted: [[-0.00034152 -0.00062989]\n", + " [ 0.00194981 -0.00132433]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[ 0.00039749 -0.00071024]\n", + " [-0.00043422 -0.00030029]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[ 5.8063609e-04 -3.1044992e-04]\n", + " [-3.5747886e-05 -1.1310205e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[-2.4776068e-04 -6.0218445e-05]\n", + " [-4.6476722e-05 -4.5308471e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 272: Predicted: [[ 0.00016707 -0.00090466]\n", + " [ 0.0012742 -0.00138314]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 273: Predicted: [[-0.00352571 -0.00159172]\n", + " [ 0.41614592 0.7484088 ]], True: [[0.5 0.875]\n", + " [0. 0. ]]\n", + "Tile 274: Predicted: [[ 0.0003492 -0.00021709]\n", + " [-0.00022563 -0.0014252 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[ 1.0110205e-04 -8.6405029e-04]\n", + " [-1.4595687e-05 -1.7595142e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[ 0.00012386 -0.00114402]\n", + " [-0.00031634 -0.00057041]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[0.00199234 0.0023067 ]\n", + " [0.0192286 0.21452227]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 278: Predicted: [[ 0.00046199 -0.00021282]\n", + " [ 0.0002524 -0.0003055 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 279: Predicted: [[-0.00164965 0.00377004]\n", + " [ 0.4707768 0.69038075]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 280: Predicted: [[ 0.00027882 -0.00087399]\n", + " [-0.00059271 -0.00174572]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 281: Predicted: [[ 4.7552865e-05 -7.5165840e-04]\n", + " [ 7.7962875e-04 -3.1895936e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[ 0.0002595 -0.00074877]\n", + " [-0.00047346 -0.00124069]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 283: Predicted: [[ 0.00020593 -0.00084126]\n", + " [-0.00075172 -0.00176328]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 284: Predicted: [[ 0.00047975 -0.0004699 ]\n", + " [-0.00076412 -0.00143034]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[ 0.00050427 -0.00076498]\n", + " [-0.00043149 -0.00057709]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 286: Predicted: [[-0.00620689 0.00139823]\n", + " [ 0.21651427 0.7521561 ]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 287: Predicted: [[ 0.00044898 -0.00049808]\n", + " [ 0.00060848 -0.0015915 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 288: Predicted: [[-0.00031128 -0.0009397 ]\n", + " [-0.00010498 -0.00076197]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[-0.00011628 -0.00063943]\n", + " [-0.00028402 -0.0004397 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 290: Predicted: [[ 0.00022928 -0.00095571]\n", + " [-0.00014007 -0.00060823]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 291: Predicted: [[-2.8725695e-03 3.6167208e-04]\n", + " [ 7.8862369e-01 5.8233660e-01]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 292: Predicted: [[ 0.00052592 -0.00024528]\n", + " [-0.00119462 -0.00167064]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 293: Predicted: [[ 0.00030105 -0.00068328]\n", + " [-0.00054968 -0.00114058]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 294: Predicted: [[ 6.4979773e-05 -8.3917315e-04]\n", + " [-6.2286854e-05 -1.7091632e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 295: Predicted: [[-2.6003923e-05 -5.4360775e-04]\n", + " [-3.4257770e-05 -1.0397956e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 296: Predicted: [[ 0.00037419 -0.00076972]\n", + " [ 0.00031915 -0.00071048]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 297: Predicted: [[-0.00570208 -0.00123775]\n", + " [ 0.7554884 0.10250159]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 298: Predicted: [[ 0.00685259 -0.00144983]\n", + " [ 0.01428555 0.11766509]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 299: Predicted: [[-3.1285919e-05 -1.1681388e-03]\n", + " [-5.6283921e-04 -1.5922785e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 300: Predicted: [[ 0.00038998 -0.0006958 ]\n", + " [ 0.00023267 -0.00078393]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[ 0.00060856 0.00012127]\n", + " [ 0.00072805 -0.00126837]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 302: Predicted: [[ 0.0002677 -0.00069906]\n", + " [ 0.00024115 -0.00086135]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 303: Predicted: [[ 0.00045293 -0.00062648]\n", + " [-0.00017738 -0.00076129]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 304: Predicted: [[ 3.0942564e-04 1.5808729e-04]\n", + " [ 1.5690923e-05 -9.5601380e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 305: Predicted: [[ 1.9659195e-04 -9.6693489e-04]\n", + " [-9.4637275e-05 -7.2760135e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[ 0.0004837 -0.00056125]\n", + " [-0.00013304 -0.0009443 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 307: Predicted: [[-6.3353218e-05 -8.4987161e-04]\n", + " [ 2.3211539e-04 -6.3242018e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[ 0.00040423 -0.00051513]\n", + " [-0.00018178 -0.00113468]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 309: Predicted: [[ 0.0002975 -0.00040804]\n", + " [ 0.00044236 -0.00214074]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 310: Predicted: [[ 0.00329741 -0.00119763]\n", + " [ 0.36786723 0.00168008]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 311: Predicted: [[ 0.00029082 -0.00046711]\n", + " [-0.0005758 -0.00098768]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[ 0.00169221 -0.00454157]\n", + " [ 0.3710836 0.15086928]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 313: Predicted: [[-1.2136996e-05 -3.8050259e-03]\n", + " [ 7.6585487e-03 2.6995265e-01]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 314: Predicted: [[ 4.2345095e-04 -9.0843643e-04]\n", + " [ 5.9373677e-05 -4.5926869e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 315: Predicted: [[ 3.9209146e-05 -6.8539084e-04]\n", + " [-5.7522953e-04 -6.7677349e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[ 0.00013203 -0.00107393]\n", + " [-0.00033537 -0.0006854 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 317: Predicted: [[-0.00037131 -0.00081405]\n", + " [ 0.00048367 -0.00092096]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 318: Predicted: [[ 0.0002292 -0.00015005]\n", + " [-0.00018085 -0.00163792]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[-0.00333218 -0.00331718]\n", + " [ 0.29306045 0.7620435 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 320: Predicted: [[-0.00034016 -0.00087985]\n", + " [ 0.0002096 -0.00104083]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 321: Predicted: [[ 0.00034118 -0.00024153]\n", + " [-0.00072212 -0.00077287]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[-0.00020297 -0.00062365]\n", + " [ 0.00193598 0.00091181]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[ 1.7984305e-05 -9.1650343e-04]\n", + " [ 3.8467348e-05 -8.0925226e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[-5.2144285e-05 -6.7116233e-04]\n", + " [ 8.3254278e-04 -1.1993721e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 325: Predicted: [[ 0.00056445 -0.00072328]\n", + " [-0.00028564 -0.00075837]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[ 2.9805838e-04 -7.5742666e-04]\n", + " [ 5.8420002e-05 -6.4179301e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[-0.0033119 -0.00304133]\n", + " [ 0.13039061 0.35557845]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 328: Predicted: [[ 0.00102202 0.0003493 ]\n", + " [-0.00088335 -0.00054844]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[-0.00012917 -0.0008148 ]\n", + " [ 0.00191583 -0.00081982]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 330: Predicted: [[ 1.5664706e-04 -6.3367450e-04]\n", + " [-4.6782196e-05 -1.5322715e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[ 5.9145503e-05 -5.5669888e-04]\n", + " [-3.0139834e-04 -1.3637617e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[ 0.00011905 -0.00027273]\n", + " [ 0.00060999 -0.00064462]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 333: Predicted: [[ 0.00029568 -0.00054413]\n", + " [-0.00041196 -0.00095102]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 334: Predicted: [[-3.0263094e-04 2.1525699e-04]\n", + " [ 3.1389296e-05 1.4172159e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[ 1.4267862e-04 -8.4355945e-04]\n", + " [-5.8367848e-05 -6.3920766e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 336: Predicted: [[ 0.00059218 -0.00072238]\n", + " [-0.00061481 -0.00076738]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 337: Predicted: [[ 0.00011917 -0.00031581]\n", + " [-0.00045374 -0.00234096]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 338: Predicted: [[ 0.00026294 -0.00081334]\n", + " [-0.00023778 -0.0006891 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 339: Predicted: [[ 0.00018698 -0.00061165]\n", + " [-0.00017693 -0.00087609]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 340: Predicted: [[ 0.00052281 -0.00026849]\n", + " [ 0.00018921 -0.00114597]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[ 0.00014087 -0.00101541]\n", + " [-0.00030655 -0.00055605]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 342: Predicted: [[ 0.00040854 -0.00067116]\n", + " [-0.00085114 -0.00098147]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[ 0.00026076 -0.0005445 ]\n", + " [-0.00097571 -0.00137813]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 344: Predicted: [[-0.00576585 -0.00164923]\n", + " [ 0.67089546 0.38218653]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 345: Predicted: [[ 0.00039564 -0.0007485 ]\n", + " [-0.00046117 -0.00146132]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[ 0.00058633 -0.00055743]\n", + " [-0.00035974 -0.00076531]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 347: Predicted: [[ 0.00021736 -0.00089435]\n", + " [-0.00038257 -0.00122143]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[ 0.00030546 -0.00055352]\n", + " [-0.0004154 -0.0012556 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 349: Predicted: [[ 0.00028423 -0.00071945]\n", + " [-0.00065443 -0.00071903]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 350: Predicted: [[-0.00014301 -0.00102402]\n", + " [-0.00035033 -0.00140429]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 351: Predicted: [[ 0.00018411 -0.00072506]\n", + " [ 0.00035952 -0.00072295]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[ 0.00020334 -0.00085509]\n", + " [-0.00019161 -0.00140511]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 353: Predicted: [[ 6.0781371e-05 -7.2411500e-04]\n", + " [-5.6123734e-04 -1.1816695e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 354: Predicted: [[ 8.7587629e-05 2.1341897e-05]\n", + " [-1.3608485e-04 -1.5478060e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 355: Predicted: [[ 4.1302759e-05 -8.8281959e-04]\n", + " [ 1.4766306e-04 -6.1184168e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 356: Predicted: [[ 0.00021159 -0.00071093]\n", + " [ 0.00040648 -0.00062469]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[ 0.00045005 -0.00063247]\n", + " [-0.00010803 -0.00134643]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[ 2.3267698e-04 -7.0984155e-04]\n", + " [-5.1856041e-06 -1.5060008e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[ 0.00017603 -0.00077953]\n", + " [-0.00054968 -0.00154446]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[ 0.00025766 -0.00077139]\n", + " [ 0.00019405 -0.00049358]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[-0.00461397 -0.00443765]\n", + " [ 0.7783357 0.20464724]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 362: Predicted: [[ 0.00018879 -0.00082613]\n", + " [ 0.00015932 -0.00120199]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[ 5.6964811e-05 -1.0755397e-03]\n", + " [-4.1633099e-04 -1.2886524e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[ 0.0005823 -0.00057769]\n", + " [-0.00013934 -0.0005767 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 365: Predicted: [[ 5.1949616e-04 4.9593858e-05]\n", + " [ 9.5516443e-06 -4.8183650e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 366: Predicted: [[-0.00016293 -0.00036777]\n", + " [-0.00154614 -0.0016953 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 367: Predicted: [[ 0.00049282 -0.00076734]\n", + " [-0.00042801 -0.00065183]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[ 0.0004791 -0.0007599 ]\n", + " [-0.00038844 -0.0015368 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 369: Predicted: [[ 0.00015944 -0.00051817]\n", + " [ 0.00017622 -0.00116424]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 370: Predicted: [[ 4.4945581e-04 -6.4778811e-04]\n", + " [-5.6467950e-05 -4.5610964e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 371: Predicted: [[ 0.00033954 -0.00059331]\n", + " [-0.00018261 -0.00090032]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 372: Predicted: [[ 0.00020284 -0.00033628]\n", + " [-0.00022715 -0.00108364]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[ 0.00257527 -0.00184516]\n", + " [ 0.47130847 0.17268294]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 374: Predicted: [[ 0.00020511 -0.00083582]\n", + " [ 0.00016917 -0.00042664]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 375: Predicted: [[ 0.00020381 -0.00058451]\n", + " [-0.00027929 -0.00122719]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[-2.9602554e-05 -1.1448506e-03]\n", + " [-4.0404499e-05 -8.7933242e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[0.03163448 0.00166802]\n", + " [0.7533308 0.29851577]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 378: Predicted: [[-0.00013866 -0.00084195]\n", + " [ 0.00026638 -0.0005777 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[ 0.00036812 -0.00075902]\n", + " [ 0.0005507 -0.00042347]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 380: Predicted: [[ 4.0245266e-04 -4.9775100e-04]\n", + " [-4.4330955e-06 -1.0227934e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 381: Predicted: [[ 0.0002818 -0.00100324]\n", + " [-0.00079602 -0.00154787]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 382: Predicted: [[ 0.00040987 -0.00053878]\n", + " [-0.00014029 -0.00126183]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 383: Predicted: [[-0.00439227 0.00167165]\n", + " [ 0.5176818 0.37079087]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 384: Predicted: [[-0.00020381 -0.00037362]\n", + " [-0.0006355 -0.00125517]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 385: Predicted: [[ 0.00029282 -0.00049701]\n", + " [-0.00139707 -0.00095583]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 386: Predicted: [[ 8.9039095e-06 -8.8200852e-04]\n", + " [ 4.6118349e-04 -1.1331961e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[ 0.00043301 -0.00094844]\n", + " [-0.00070506 -0.00106367]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 388: Predicted: [[ 0.00020617 -0.00082373]\n", + " [-0.00054938 -0.00047766]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 389: Predicted: [[ 7.5407233e-04 -9.9635508e-05]\n", + " [-1.2117997e-03 -1.8794760e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[ 0.00060485 -0.00073577]\n", + " [-0.00028661 -0.00139315]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[ 8.1397593e-06 -9.4267301e-04]\n", + " [-5.0548464e-04 -9.7165257e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[ 1.9810023e-04 -7.7515590e-04]\n", + " [ 7.7955425e-05 -9.6902251e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 393: Predicted: [[ 3.5243272e-04 -7.2773563e-04]\n", + " [-2.5898218e-05 -5.2973628e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[ 0.0013918 -0.0005612 ]\n", + " [ 0.09886591 0.00208359]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 395: Predicted: [[-3.7048012e-05 -2.7995842e-04]\n", + " [ 2.4481118e-04 -1.2695715e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 396: Predicted: [[-8.7273307e-05 -9.5624145e-04]\n", + " [ 1.6845018e-04 -5.7570636e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 397: Predicted: [[ 0.00038865 -0.00052467]\n", + " [-0.00053766 -0.00090839]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 398: Predicted: [[ 3.5121711e-04 -4.7289807e-04]\n", + " [ 7.2360039e-05 -1.7551631e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 399: Predicted: [[ 0.00019264 -0.00091051]\n", + " [-0.00091071 -0.00117345]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[-7.5560063e-05 -6.2636897e-04]\n", + " [-2.6524067e-06 -1.0425672e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[ 3.9179786e-04 -7.4057974e-04]\n", + " [-9.1195107e-06 -6.6535920e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[ 3.4714746e-04 -6.7186862e-04]\n", + " [-1.6562641e-05 -6.4889342e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[-0.0002038 -0.00086718]\n", + " [ 0.00034436 -0.00081805]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[-0.00044142 0.00532722]\n", + " [ 0.00466345 0.21155041]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 405: Predicted: [[ 5.8830972e-04 -4.4211745e-04]\n", + " [-1.3917685e-05 -7.5514615e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[-4.0119048e-05 -5.5630138e-04]\n", + " [ 1.0003075e-03 -8.2090497e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 407: Predicted: [[ 0.00015667 -0.0009116 ]\n", + " [-0.00032181 -0.00140786]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 408: Predicted: [[ 6.5980479e-05 -9.9176029e-04]\n", + " [-1.8870085e-04 -1.1071786e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[-0.00032461 -0.0007652 ]\n", + " [ 0.0018576 -0.00052481]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[-0.0002532 -0.00114694]\n", + " [ 0.00096765 -0.00072898]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 411: Predicted: [[-6.8838242e-05 -3.6250445e-04]\n", + " [-4.9211085e-05 -2.7733520e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 412: Predicted: [[ 0.00039551 -0.00087232]\n", + " [ 0.00064543 -0.00097692]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[-7.1087386e-05 -6.7427527e-04]\n", + " [ 7.7877939e-04 -4.5970082e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 414: Predicted: [[ 0.00032567 -0.00076088]\n", + " [-0.00032569 -0.00067142]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[ 0.00050539 -0.00025457]\n", + " [ 0.00014322 -0.00123634]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 416: Predicted: [[ 0.00025669 -0.0010279 ]\n", + " [-0.00038081 -0.00125551]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[ 2.0188279e-05 -7.5222953e-04]\n", + " [-1.0091066e-04 -2.0607337e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[ 0.00017328 -0.00083142]\n", + " [ 0.00044981 -0.00028456]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 419: Predicted: [[ 0.0002749 -0.00068977]\n", + " [-0.00023698 -0.000822 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[ 0.00047545 -0.0005937 ]\n", + " [-0.00030226 -0.00136352]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[ 0.00035212 -0.00082479]\n", + " [ 0.00015546 -0.00068756]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[ 0.00026379 -0.00034412]\n", + " [-0.00029961 -0.0012064 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 423: Predicted: [[ 4.5180274e-04 -7.7092886e-04]\n", + " [-9.9913776e-04 -2.1427870e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 424: Predicted: [[-0.00117083 -0.00810639]\n", + " [ 0.2999655 0.75912714]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 425: Predicted: [[-0.00013144 -0.00085004]\n", + " [ 0.00148329 -0.00036009]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[ 0.00048812 -0.0004561 ]\n", + " [-0.00016925 -0.0012263 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[-0.00047463 -0.00083348]\n", + " [-0.00058503 -0.00107741]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[0.482426 0.35403925]\n", + " [0.6227901 0.3703284 ]], True: [[0.375 0.375]\n", + " [0.875 0.25 ]]\n", + "Tile 429: Predicted: [[ 0.00039378 -0.00069959]\n", + " [-0.00039259 -0.00053202]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[ 0.00028907 -0.00073061]\n", + " [-0.0005111 -0.00114311]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[ 0.00034184 -0.00063581]\n", + " [-0.00043536 -0.00104985]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[ 0.00020963 -0.00091825]\n", + " [ 0.00019187 -0.0008431 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[-5.7026278e-05 -1.0319562e-03]\n", + " [-7.4848533e-05 -3.6899745e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[ 3.1539705e-05 -5.6196941e-04]\n", + " [-1.3215095e-04 -1.0548756e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[ 0.00019424 -0.00090939]\n", + " [-0.00021932 -0.00091206]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[ 0.00036239 -0.00044247]\n", + " [-0.00088232 -0.00260628]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 437: Predicted: [[ 0.0001442 -0.00090469]\n", + " [ 0.0005087 -0.00087292]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[-2.9720366e-05 -6.7737635e-04]\n", + " [-3.3377856e-04 -1.3063625e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[ 0.00034751 -0.00072353]\n", + " [-0.00022446 -0.00086128]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[ 0.0003162 -0.00065997]\n", + " [-0.00013626 -0.00057473]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 441: Predicted: [[ 0.00048102 -0.00054335]\n", + " [ 0.00056824 -0.00095302]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[ 0.00072523 -0.00069044]\n", + " [-0.00022297 -0.00184713]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 443: Predicted: [[ 0.0001611 -0.00078248]\n", + " [-0.00020873 -0.0012344 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[ 2.5785551e-04 -7.8533095e-04]\n", + " [ 8.9861453e-05 -4.9173087e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[ 0.00037277 -0.00057311]\n", + " [-0.00017883 -0.00113235]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[ 0.00018079 -0.00076118]\n", + " [-0.00075617 -0.00177822]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[ 0.00023613 -0.00055748]\n", + " [-0.00035066 -0.00050327]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[ 0.00017367 -0.00066605]\n", + " [-0.0009663 -0.00158808]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 449: Predicted: [[ 0.00071891 -0.00049717]\n", + " [-0.00073653 -0.00109923]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[ 0.00044471 -0.00080374]\n", + " [-0.00068699 -0.00081109]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 451: Predicted: [[ 0.00027391 -0.00045235]\n", + " [-0.00025934 -0.00175906]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[ 0.00014684 -0.0006787 ]\n", + " [-0.00016363 -0.00130808]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 453: Predicted: [[ 0.00051378 -0.00041626]\n", + " [ 0.00047697 -0.00102291]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 454: Predicted: [[-0.00048782 -0.00107658]\n", + " [ 0.00015669 -0.00105427]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[-1.3960060e-05 -3.6931521e-04]\n", + " [-2.3052096e-04 -9.0806931e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[ 0.00048317 -0.00052382]\n", + " [-0.00035511 -0.00013988]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 457: Predicted: [[ 6.2216539e-05 -5.2594335e-04]\n", + " [-4.1034818e-04 -1.5632361e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 458: Predicted: [[ 0.00046574 -0.00053488]\n", + " [-0.00030395 0.00020269]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 459: Predicted: [[ 0.00025458 -0.00036173]\n", + " [-0.00083555 -0.00261986]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 460: Predicted: [[ 0.00038561 -0.00051407]\n", + " [-0.00043122 -0.00086392]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[ 0.00043783 -0.00032704]\n", + " [-0.00058359 -0.00162571]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 462: Predicted: [[ 2.5854120e-04 -8.1639615e-04]\n", + " [ 1.6890466e-05 -4.3633580e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[ 0.00013711 -0.00063452]\n", + " [ 0.00032923 -0.0015277 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[0.01774851 0.00388561]\n", + " [0.73765385 0.25058147]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[ 0.00058007 -0.00036325]\n", + " [-0.00088678 -0.00118843]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 466: Predicted: [[ 0.00024484 -0.00077541]\n", + " [ 0.00029006 -0.00108325]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 467: Predicted: [[ 0.00014236 -0.00062763]\n", + " [-0.00136025 -0.00204826]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 468: Predicted: [[ 0.00049148 -0.00038486]\n", + " [-0.0002156 -0.0017745 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 469: Predicted: [[-0.00458038 -0.0014172 ]\n", + " [ 0.48940915 0.05985205]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 470: Predicted: [[0.00037269 0.00105242]\n", + " [0.00492802 0.10296305]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 471: Predicted: [[ 0.00038268 -0.00069446]\n", + " [-0.00046151 -0.00238508]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 472: Predicted: [[ 0.00029761 -0.00080519]\n", + " [ 0.00059306 -0.00071466]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[ 2.9020500e-04 -8.5238408e-04]\n", + " [ 1.5988946e-05 -1.0945350e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[ 0.00052496 -0.00036445]\n", + " [-0.00042474 -0.0009663 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[ 3.3237436e-04 -8.1977370e-04]\n", + " [-4.2141974e-04 5.9522688e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[ 0.00043299 -0.00061276]\n", + " [ 0.00033744 -0.00037091]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[ 0.00048307 -0.00058812]\n", + " [ 0.0004727 -0.00052635]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 478: Predicted: [[ 0.00040306 -0.001054 ]\n", + " [ 0.00077441 -0.00150377]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[ 0.00023203 -0.00062448]\n", + " [ 0.00025013 -0.00128896]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[ 0.00012612 -0.00077102]\n", + " [-0.00015499 -0.00074689]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 481: Predicted: [[-0.00375557 0.00308398]\n", + " [-0.00552217 0.00781872]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 482: Predicted: [[ 0.00034448 -0.00065082]\n", + " [-0.00046282 -0.00187394]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 483: Predicted: [[ 2.2146828e-04 -6.3922774e-04]\n", + " [-9.5754862e-05 -1.0075122e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[ 1.8007588e-05 -9.2998502e-04]\n", + " [-4.4941902e-05 -9.5844269e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[ 0.00012778 -0.00136295]\n", + " [ 0.00153484 -0.00127868]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 486: Predicted: [[ 0.0006113 -0.0003933 ]\n", + " [-0.00030443 -0.00082725]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 487: Predicted: [[ 4.8795389e-04 -8.6169183e-04]\n", + " [-2.7604401e-05 -5.0878525e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[-7.0147682e-05 -8.3530409e-04]\n", + " [ 6.1467290e-06 -1.1382625e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[0.01854718 0.01768324]\n", + " [0.3119166 0.39140743]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 490: Predicted: [[ 0.00030343 -0.0006047 ]\n", + " [-0.00033559 -0.00122845]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[ 3.9201695e-05 -3.1209033e-04]\n", + " [ 4.4625252e-04 5.2766129e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 492: Predicted: [[ 4.2661559e-04 -6.7471579e-04]\n", + " [ 3.6589801e-05 -3.4485012e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 493: Predicted: [[ 1.2248103e-04 -1.0515256e-03]\n", + " [-4.0449202e-05 -1.3803840e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[ 0.00055925 -0.00035528]\n", + " [-0.00015716 -0.00133269]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 495: Predicted: [[ 0.00024174 -0.00061087]\n", + " [-0.00016616 -0.00199241]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 496: Predicted: [[ 0.00058445 -0.00051995]\n", + " [ 0.00020265 -0.00017756]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 497: Predicted: [[ 6.7431480e-05 -1.5022379e-04]\n", + " [-4.7904253e-04 -1.2347847e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[0.00690952 0.02216743]\n", + " [0.3329934 0.6259152 ]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 499: Predicted: [[-0.0070546 -0.0094523 ]\n", + " [ 0.506292 0.44309965]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 500: Predicted: [[ 3.7383335e-04 -8.5399061e-04]\n", + " [ 4.4308603e-05 -1.3141856e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[ 2.1879096e-05 -7.4027799e-04]\n", + " [-2.1789968e-04 -3.6446750e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[ 0.0004019 -0.00061871]\n", + " [-0.00013104 -0.00042129]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[ 0.00067618 -0.0002146 ]\n", + " [ 0.00017281 -0.00108633]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[ 0.00016648 -0.00066426]\n", + " [ 0.00010356 -0.00102001]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 505: Predicted: [[ 0.00028494 -0.0006231 ]\n", + " [ 0.00025208 -0.00080612]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[ 1.9950932e-04 -7.8504469e-04]\n", + " [ 6.0893595e-05 -1.7209947e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 507: Predicted: [[ 2.4885195e-04 -6.2998274e-04]\n", + " [ 5.9813261e-05 -1.3601109e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[ 0.0002221 -0.00073475]\n", + " [ 0.00096432 -0.00092205]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 509: Predicted: [[ 3.8512214e-04 -5.0077593e-04]\n", + " [-5.8025122e-05 -1.0410398e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[ 0.00014436 -0.00102162]\n", + " [-0.00024295 -0.00052309]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[ 0.0005286 -0.0004629 ]\n", + " [-0.0001184 -0.00169157]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 512: Predicted: [[ 0.00060315 -0.00064265]\n", + " [-0.00058253 -0.00120886]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 513: Predicted: [[-2.0153821e-05 -8.7862456e-04]\n", + " [-1.2640655e-04 -6.7517906e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[ 0.00037669 -0.00080266]\n", + " [-0.0004287 -0.00128224]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[ 0.00021712 -0.00068648]\n", + " [-0.00055125 -0.0016424 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[ 1.4137616e-04 -4.0600129e-04]\n", + " [ 7.1957707e-05 -1.4812052e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 517: Predicted: [[ 0.00016344 -0.00061318]\n", + " [ 0.0003525 -0.00134634]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[ 0.00040568 -0.00068942]\n", + " [-0.00101692 -0.0008968 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 519: Predicted: [[ 8.836528e-05 -4.829429e-04]\n", + " [-4.984066e-04 -1.308471e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[ 9.4909128e-04 3.9436098e-05]\n", + " [-3.1217933e-04 -4.8023462e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[-0.00102174 0.00180795]\n", + " [ 0.33776417 0.02523893]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 522: Predicted: [[0.00290922 0.0004507 ]\n", + " [0.00743306 0.10334906]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 523: Predicted: [[ 5.8186240e-05 -8.6404110e-04]\n", + " [ 6.5952539e-05 -1.3124347e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 524: Predicted: [[ 3.7721614e-04 -4.9547007e-04]\n", + " [-5.5519491e-04 -6.8210065e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[ 0.00511088 -0.00238012]\n", + " [ 0.39171687 0.2285099 ]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 526: Predicted: [[-0.00488179 0.00454491]\n", + " [ 0.00611641 0.42006922]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[ 0.00029173 -0.00048976]\n", + " [-0.00013518 -0.00117894]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[ 0.00028182 -0.00033323]\n", + " [-0.00029288 -0.00058027]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 529: Predicted: [[ 0.00040944 -0.00062077]\n", + " [-0.00030144 -0.00116611]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 530: Predicted: [[ 0.00022924 -0.00069316]\n", + " [ 0.00062749 -0.00031524]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[ 0.00015812 -0.00116838]\n", + " [-0.00048853 -0.00041773]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[ 9.8486897e-05 -8.6670247e-04]\n", + " [-4.6948344e-04 -1.1535808e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[ 0.0004831 -0.00032005]\n", + " [-0.00128141 -0.00180466]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[ 1.9238004e-04 -7.3306478e-04]\n", + " [-1.5631318e-05 -7.4994564e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 535: Predicted: [[ 0.00027309 -0.00097215]\n", + " [-0.00033399 -0.00070822]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 536: Predicted: [[ 3.5367929e-04 -4.8424251e-04]\n", + " [-4.2647123e-05 -1.8389151e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[ 0.00012706 -0.00075477]\n", + " [ 0.00054342 -0.00023036]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 538: Predicted: [[ 0.00039543 -0.00049776]\n", + " [-0.00019842 -0.00048311]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[ 0.0003416 -0.00098382]\n", + " [-0.00015856 -0.00035085]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[ 0.00038243 -0.00067569]\n", + " [ 0.0003439 -0.00064714]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[-0.00240397 -0.00426156]\n", + " [ 0.20152935 0.75963134]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 542: Predicted: [[ 0.00035778 -0.00067745]\n", + " [-0.00129451 -0.0012451 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 543: Predicted: [[ 1.6300054e-04 -9.2297414e-04]\n", + " [ 5.8263540e-05 -9.5351040e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 544: Predicted: [[ 0.00012917 -0.00081859]\n", + " [-0.00025143 -0.00115386]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[ 0.00062501 -0.00063618]\n", + " [-0.00064836 -0.00016598]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[ 0.0005529 -0.00071524]\n", + " [ 0.00077852 -0.00079228]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[ 0.00033267 -0.00058722]\n", + " [ 0.00021517 -0.00105678]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 548: Predicted: [[-0.00021502 -0.00097917]\n", + " [ 0.00051297 -0.00087254]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 549: Predicted: [[ 5.8223703e-04 -7.0082460e-04]\n", + " [-9.7565353e-05 -1.6061962e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[ 0.00017036 -0.00069229]\n", + " [ 0.0006716 -0.0017035 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[ 0.00044301 -0.00043902]\n", + " [-0.00020666 -0.00141528]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 552: Predicted: [[ 0.00034566 -0.00052137]\n", + " [-0.00069339 -0.00025285]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[ 0.00047599 -0.00083552]\n", + " [ 0.00023368 -0.00093323]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 554: Predicted: [[ 0.00117414 0.00014606]\n", + " [ 0.00026609 -0.00037985]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[ 0.00031905 -0.0007117 ]\n", + " [-0.00080952 -0.00068761]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 556: Predicted: [[ 0.00026656 -0.00039734]\n", + " [-0.00052179 -0.00090887]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[ 0.0005432 -0.00055415]\n", + " [-0.00033689 -0.00055765]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 558: Predicted: [[ 2.6770448e-04 -8.5065857e-04]\n", + " [-3.6284328e-06 -4.9537420e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[ 0.00077339 -0.00019692]\n", + " [-0.00028844 -0.00187383]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 560: Predicted: [[ 1.6604131e-04 -2.5193027e-04]\n", + " [-2.9362738e-05 -1.8271431e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 561: Predicted: [[ 2.1357369e-04 -7.1155565e-04]\n", + " [-7.5623393e-05 -1.0613799e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 562: Predicted: [[ 0.00062573 -0.00044608]\n", + " [-0.00032986 -0.00239395]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 563: Predicted: [[ 0.00041926 -0.00059794]\n", + " [ 0.00015428 -0.00090684]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[-1.8128194e-06 -5.8435247e-04]\n", + " [-2.9466301e-04 -1.4807209e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 565: Predicted: [[ 0.00026256 -0.00093072]\n", + " [-0.00071237 -0.00161358]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 566: Predicted: [[ 0.00057206 -0.00022277]\n", + " [-0.00049791 -0.00113944]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 567: Predicted: [[ 0.00013836 -0.00085218]\n", + " [ 0.00016162 -0.00109504]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 568: Predicted: [[-1.5621446e-04 -1.1913278e-03]\n", + " [-7.2076917e-05 -1.8514618e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 569: Predicted: [[8.6355824e-03 5.1127648e-04]\n", + " [5.1237695e-02 6.7761785e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 570: Predicted: [[ 0.00047486 -0.00050183]\n", + " [ 0.00031517 -0.00095867]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 571: Predicted: [[-0.00673101 -0.00446923]\n", + " [ 0.6045228 0.751649 ]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 572: Predicted: [[ 5.0181756e-04 -7.6459028e-04]\n", + " [-1.1450052e-04 -9.8831952e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[ 7.9889316e-05 -9.0758532e-04]\n", + " [ 4.4140220e-04 -4.8206002e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[ 0.00028813 -0.00075064]\n", + " [-0.00033989 -0.00087749]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[ 6.3921791e-05 -1.0003657e-03]\n", + " [ 7.8827143e-06 -1.2037680e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[ 0.00036703 -0.00084208]\n", + " [-0.00142773 -0.00216732]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[ 0.00052917 -0.00066113]\n", + " [-0.00026143 -0.00061269]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[ 8.9437701e-05 -7.7842578e-04]\n", + " [ 2.1812320e-04 -1.0134578e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 579: Predicted: [[ 4.7723809e-04 -6.8972347e-04]\n", + " [-6.6645443e-05 -1.0781735e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[ 2.0792149e-04 -1.1307667e-03]\n", + " [-8.1151724e-05 -1.1064187e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[ 0.00018352 -0.00087012]\n", + " [-0.00027584 -0.00143324]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 582: Predicted: [[ 0.00030621 -0.00012677]\n", + " [ 0.00017351 -0.00202028]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 583: Predicted: [[ 0.00022438 -0.00082011]\n", + " [-0.00027322 -0.00149276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 584: Predicted: [[ 7.0889480e-05 -6.5016939e-04]\n", + " [-1.5919656e-04 -1.2576357e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 585: Predicted: [[ 0.00029617 -0.0007801 ]\n", + " [-0.00042298 -0.00161836]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[ 1.6617170e-04 -1.1984794e-03]\n", + " [-7.9229474e-05 1.1665374e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[ 0.00062824 -0.00070627]\n", + " [-0.00108147 -0.00112244]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[ 0.00026887 -0.00070599]\n", + " [ 0.00043672 -0.0017767 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[ 0.00035062 -0.00059883]\n", + " [ 0.00030547 -0.00064585]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 590: Predicted: [[ 0.00042874 -0.00062795]\n", + " [-0.00132287 -0.00129569]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[0.0035941 0.00186858]\n", + " [0.08305152 0.51604 ]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 592: Predicted: [[ 3.4085009e-05 -7.2438788e-04]\n", + " [-3.0125678e-04 -8.3047897e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[ 0.00061074 -0.00016333]\n", + " [ 0.00024887 -0.00075968]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 594: Predicted: [[ 4.5408495e-04 -6.2885747e-04]\n", + " [-9.7751617e-06 -4.6821684e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[ 0.00050696 -0.00065302]\n", + " [-0.00062172 -0.00103111]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 596: Predicted: [[ 4.6678353e-05 -8.2336058e-04]\n", + " [-1.0673255e-03 -1.2263805e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 597: Predicted: [[-3.39271501e-05 -7.24496262e-04]\n", + " [ 1.17085874e-04 -3.48053873e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 598: Predicted: [[ 0.0001825 -0.00068323]\n", + " [-0.00014018 -0.00127273]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[ 0.00030141 -0.00101329]\n", + " [-0.0002945 -0.00071001]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 600: Predicted: [[ 0.00063504 -0.00029441]\n", + " [-0.0006569 -0.00186467]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[-0.00040952 0.00042324]\n", + " [ 0.00995032 0.00747479]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 602: Predicted: [[ 0.00010116 -0.00092373]\n", + " [-0.00102635 -0.00073494]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 603: Predicted: [[0.00537083 0.0015681 ]\n", + " [0.50145864 0.6630001 ]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 604: Predicted: [[-5.9339311e-03 -7.2431110e-05]\n", + " [ 1.2060265e-01 6.6528636e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 605: Predicted: [[ 0.00071697 -0.0002453 ]\n", + " [-0.00061186 -0.00177548]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 606: Predicted: [[ 0.000555 -0.00011316]\n", + " [-0.00056021 -0.00080604]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[0.00105372 0.00399175]\n", + " [0.3395162 0.5143849 ]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 608: Predicted: [[ 8.4411819e-05 -7.0527423e-04]\n", + " [ 3.1017512e-04 -1.1976138e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 609: Predicted: [[ 0.00018376 -0.00045059]\n", + " [-0.00049766 -0.00150369]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 610: Predicted: [[ 0.00032027 -0.00067003]\n", + " [ 0.00010454 -0.001258 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[ 0.00063436 -0.00025689]\n", + " [-0.00035113 -0.00116148]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[ 0.00048224 -0.00052545]\n", + " [-0.00064351 -0.00165502]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 613: Predicted: [[ 0.00025909 -0.0007889 ]\n", + " [-0.00062773 -0.00142213]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[ 0.00018822 -0.00070903]\n", + " [-0.00038608 -0.00124364]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[ 4.2848778e-04 -3.6902452e-04]\n", + " [-4.7802925e-05 -1.6703680e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[ 0.00088731 -0.00076308]\n", + " [ 0.00047144 -0.00048821]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 617: Predicted: [[ 0.00042998 -0.00066052]\n", + " [-0.00139958 -0.00174616]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 618: Predicted: [[ 0.00026487 -0.00078466]\n", + " [ 0.00018705 -0.00103568]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 619: Predicted: [[-8.6466316e-05 -7.2053313e-04]\n", + " [ 3.5077333e-05 -1.2623668e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 620: Predicted: [[ 4.9728900e-05 -7.7729713e-04]\n", + " [ 1.1160970e-05 -7.3305517e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[ 1.7397571e-04 -6.4054510e-04]\n", + " [ 9.8772347e-05 -1.4563352e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 622: Predicted: [[ 3.1702593e-04 -1.0460480e-03]\n", + " [ 9.7632408e-05 -5.2765012e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 623: Predicted: [[ 0.00027133 -0.0007917 ]\n", + " [-0.00095565 -0.00172078]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[ 0.00013937 -0.00089332]\n", + " [ 0.00028262 -0.00078174]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 625: Predicted: [[ 0.00021997 -0.00091964]\n", + " [ 0.00023769 -0.00053058]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 626: Predicted: [[ 9.9119265e-05 -8.1699359e-04]\n", + " [ 3.9837509e-04 -1.0392144e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 627: Predicted: [[-0.00408836 -0.00162508]\n", + " [ 0.30198917 0.7530326 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 628: Predicted: [[-6.9834292e-05 -9.5079938e-04]\n", + " [-6.9900602e-04 -1.1803433e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[ 0.00041082 -0.0005495 ]\n", + " [-0.00025229 -0.00088083]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[ 1.08598266e-04 -6.96376490e-04]\n", + " [-7.71805644e-05 -7.59810209e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[ 0.00025875 -0.00074565]\n", + " [ 0.00010785 -0.00112911]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[ 0.00042656 -0.00046832]\n", + " [ 0.00053734 -0.00102733]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 633: Predicted: [[ 3.0418509e-04 -8.5269724e-04]\n", + " [ 4.0531158e-05 -1.5754029e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 634: Predicted: [[ 0.00021705 -0.00053149]\n", + " [ 0.00022827 -0.00071315]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 635: Predicted: [[ 6.7595858e-05 -7.5117807e-04]\n", + " [ 4.0207058e-04 -2.1138936e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[ 0.00069245 -0.00046317]\n", + " [ 0.00032707 -0.00169677]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[ 0.00048169 -0.00069035]\n", + " [ 0.00017549 -0.00091582]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[ 4.4397078e-05 -9.7781164e-04]\n", + " [-3.2904744e-04 -6.3659996e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[ 3.9073220e-04 -3.8499478e-04]\n", + " [-3.2469630e-05 -8.6913258e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[-8.7620690e-05 -7.4650446e-04]\n", + " [ 1.5341491e-04 -1.2046620e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 641: Predicted: [[ 1.2213085e-04 -4.8557116e-04]\n", + " [ 2.4944544e-05 -1.1401102e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 642: Predicted: [[-0.00705194 -0.00301388]\n", + " [ 0.6537585 0.4412774 ]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 643: Predicted: [[-0.00031383 -0.0002441 ]\n", + " [-0.00025935 -0.00073148]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[ 0.00024735 -0.00086304]\n", + " [ 0.00057614 -0.00069644]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 645: Predicted: [[ 0.00045318 -0.0003391 ]\n", + " [-0.00046353 -0.00187597]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[ 0.00023316 -0.00081369]\n", + " [-0.00035265 -0.00016202]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 647: Predicted: [[ 0.00064045 -0.00047955]\n", + " [-0.00014301 -0.00099866]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 648: Predicted: [[ 0.00014801 -0.00097351]\n", + " [ 0.00079152 -0.00138753]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 649: Predicted: [[ 3.3322396e-04 -7.1476208e-04]\n", + " [-5.4590404e-05 -1.7773360e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 650: Predicted: [[ 0.00174551 -0.00765349]\n", + " [ 0.63626397 0.8383445 ]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 651: Predicted: [[-0.00027961 -0.00099456]\n", + " [ 0.00017823 -0.00095184]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 652: Predicted: [[-0.0005866 -0.00106935]\n", + " [ 0.00048602 0.00183716]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 653: Predicted: [[ 9.6682925e-05 -4.9383874e-04]\n", + " [ 1.4208257e-04 -1.1801645e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 654: Predicted: [[ 2.5412068e-05 -6.7316956e-04]\n", + " [-7.0729852e-04 -2.0288974e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[ 0.00039944 -0.00078537]\n", + " [-0.00037037 -0.00040454]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[ 0.00022847 -0.00063839]\n", + " [ 0.00032204 -0.00084236]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 657: Predicted: [[-0.00024185 -0.00085749]\n", + " [-0.00078494 -0.00118934]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[-0.00014935 -0.00086462]\n", + " [-0.00012423 -0.00195988]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 659: Predicted: [[0.01197923 0.00631824]\n", + " [0.20693246 0.7433268 ]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 660: Predicted: [[ 0.00035508 -0.00061334]\n", + " [-0.00032839 -0.00095293]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[0.04812964 0.04350721]\n", + " [0.45123288 0.4609324 ]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 662: Predicted: [[ 7.2391285e-04 -8.0630300e-05]\n", + " [ 2.1830946e-04 -9.2662871e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 663: Predicted: [[ 0.00015578 -0.00067385]\n", + " [-0.00027185 -0.00126153]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[ 0.00045947 -0.00089448]\n", + " [-0.00012231 -0.00070879]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[ 0.00027204 -0.000624 ]\n", + " [ 0.00036686 -0.00083368]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[ 6.912290e-04 -3.777779e-04]\n", + " [-5.173683e-05 -4.002601e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 667: Predicted: [[ 1.6896520e-04 -6.9890945e-04]\n", + " [-7.8901649e-05 -1.3443157e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[ 2.4906802e-04 -4.9597275e-04]\n", + " [-4.8078597e-05 -1.2186691e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[ 4.2384025e-05 -8.1180915e-04]\n", + " [-3.3751875e-04 -1.1923760e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[ 9.7835436e-06 -3.5712455e-04]\n", + " [ 7.9400092e-04 -1.8868968e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[ 0.00042057 -0.00045425]\n", + " [ 0.0003229 -0.00077715]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[ 0.00022486 -0.00055141]\n", + " [ 0.00084963 -0.0019723 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[ 0.00050612 -0.00052777]\n", + " [-0.00067085 -0.00020311]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 674: Predicted: [[ 0.00013561 -0.00109858]\n", + " [-0.00056203 -0.00138525]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[ 0.00063775 0.00010528]\n", + " [-0.0004054 -0.00196471]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 676: Predicted: [[ 0.00036009 -0.00065264]\n", + " [-0.00015706 -0.001626 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 677: Predicted: [[ 2.5665388e-05 -9.1070315e-04]\n", + " [ 9.4473362e-05 -1.1415184e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[ 4.5548659e-05 -1.6342296e-04]\n", + " [-4.1764975e-04 -1.7502531e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 679: Predicted: [[ 0.00020727 -0.00081955]\n", + " [ 0.00030046 -0.00016352]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[ 0.00016712 -0.00078 ]\n", + " [ 0.00051672 -0.00102606]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[ 0.00019624 -0.0007185 ]\n", + " [-0.00040527 -0.00094245]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[ 0.00024246 -0.00103219]\n", + " [-0.00010722 -0.00081575]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[ 0.00039438 -0.0006029 ]\n", + " [ 0.00035112 -0.00058677]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[ 0.00032245 -0.00047894]\n", + " [-0.00052299 -0.00205972]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[ 0.00019254 -0.00097461]\n", + " [-0.00077859 -0.00151347]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[ 5.4108421e-04 -3.0250038e-04]\n", + " [-5.1736832e-05 -5.7645142e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[-7.6912809e-05 -4.2315590e-04]\n", + " [-1.1539310e-03 -1.8555522e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 688: Predicted: [[ 0.00059331 -0.00060539]\n", + " [-0.00022115 -0.00095075]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[-0.00010597 -0.00084129]\n", + " [-0.00092115 -0.00094373]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[ 0.00034377 -0.00083972]\n", + " [ 0.00033118 -0.00025731]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[-7.4710697e-05 -9.1629283e-04]\n", + " [ 3.8845837e-04 -1.1279881e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[ 0.00036675 -0.00054285]\n", + " [ 0.00012481 -0.0008708 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 693: Predicted: [[ 3.3495482e-04 -6.3248706e-04]\n", + " [ 7.0966780e-05 -2.0653903e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 694: Predicted: [[ 0.00054455 -0.00061777]\n", + " [ 0.00023666 -0.00047584]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 695: Predicted: [[ 0.00012443 -0.0008155 ]\n", + " [-0.00033561 -0.00098765]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[ 0.00028427 -0.00059499]\n", + " [ 0.0003245 -0.00111058]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[-0.00297961 -0.00372939]\n", + " [ 0.2569038 0.24123144]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 698: Predicted: [[ 0.00031298 -0.00127529]\n", + " [ 0.0003221 -0.00085666]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 699: Predicted: [[ 0.00041507 -0.00071291]\n", + " [-0.00024855 -0.00020385]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 700: Predicted: [[ 0.00019635 -0.0007946 ]\n", + " [ 0.00018887 -0.00215204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 701: Predicted: [[ 0.00026321 -0.00029519]\n", + " [-0.00022647 -0.0013065 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[ 4.6340027e-04 -7.0588180e-04]\n", + " [ 4.2416155e-05 -5.0771236e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[ 0.0003033 -0.00069873]\n", + " [ 0.00019281 -0.00054251]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[ 0.00039968 -0.00088635]\n", + " [-0.00021192 -0.00042456]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 705: Predicted: [[ 0.0003948 -0.00069975]\n", + " [-0.00068389 -0.00169867]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 706: Predicted: [[ 0.00019614 -0.00097236]\n", + " [ 0.00049771 -0.00028842]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[ 7.4475538e-05 -7.0830522e-04]\n", + " [ 3.3027679e-04 -4.8657507e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 708: Predicted: [[ 0.0003929 -0.00076547]\n", + " [-0.00048564 -0.00038144]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[ 2.4738186e-04 -6.9104513e-04]\n", + " [ 1.3001263e-05 -7.4598938e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 710: Predicted: [[ 0.00016119 -0.00094435]\n", + " [-0.00047788 -0.00061363]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 711: Predicted: [[ 0.000158 -0.00059845]\n", + " [-0.00044815 -0.00089148]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 712: Predicted: [[ 2.1215063e-05 -6.1990583e-04]\n", + " [ 5.9036911e-04 -3.8578361e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 713: Predicted: [[ 2.1348381e-04 -6.8540586e-04]\n", + " [-4.0829182e-05 -9.5518678e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[-4.0283240e-04 6.3779377e-03]\n", + " [ 7.4814951e-01 4.0146786e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 715: Predicted: [[ 0.00043529 -0.00156759]\n", + " [-0.00133641 0.21331292]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 716: Predicted: [[ 2.5133672e-04 -6.3002697e-04]\n", + " [ 8.1650913e-05 -1.3463199e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 717: Predicted: [[ 0.00401722 -0.0043445 ]\n", + " [ 0.4428479 0.01642404]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 718: Predicted: [[ 0.00015096 -0.00034168]\n", + " [-0.00084208 -0.00053761]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[ 0.00049229 -0.00085994]\n", + " [-0.00096601 -0.00080842]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[ 0.00025459 -0.00030565]\n", + " [ 0.00052902 -0.00088689]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[ 0.0003277 -0.00073343]\n", + " [ 0.00025435 -0.00108397]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 722: Predicted: [[ 0.00055725 -0.00057535]\n", + " [-0.00017211 -0.0007208 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 723: Predicted: [[ 0.0001242 -0.00076646]\n", + " [ 0.00012758 -0.00132035]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 724: Predicted: [[ 2.7290080e-04 -5.9790030e-04]\n", + " [-9.4249845e-05 -1.0384917e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[ 0.00044928 -0.00013787]\n", + " [ 0.00056669 -0.00129097]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 726: Predicted: [[ 7.8746234e-04 -3.5985163e-04]\n", + " [ 1.7009676e-05 -1.7956942e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 727: Predicted: [[ 1.153606e-04 -8.838438e-04]\n", + " [ 1.630187e-05 -7.328838e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[ 0.00013163 -0.00054437]\n", + " [ 0.00030696 -0.0012408 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 729: Predicted: [[ 3.8884324e-04 -7.5541140e-04]\n", + " [ 8.7834895e-05 -2.0919740e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 730: Predicted: [[-0.00569268 -0.00471192]\n", + " [ 0.5789876 0.49004143]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 731: Predicted: [[-0.00035895 -0.00087014]\n", + " [ 0.00100157 -0.00132177]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[ 0.00041361 -0.00092962]\n", + " [-0.00107822 -0.00076993]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 733: Predicted: [[-0.01152872 -0.00601898]\n", + " [ 0.50913584 0.6206756 ]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 734: Predicted: [[ 0.00027461 -0.0003842 ]\n", + " [-0.00033784 -0.00097933]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 735: Predicted: [[ 0.00018791 -0.00075064]\n", + " [ 0.00022601 -0.00093155]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[ 2.3114658e-04 -5.3214037e-04]\n", + " [-7.7851117e-05 -9.4187260e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[ 0.00041652 -0.00069011]\n", + " [ 0.00083692 -0.00045594]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[ 0.00043453 -0.00051126]\n", + " [-0.0003151 -0.00151798]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[ 3.5165832e-04 -7.0764433e-04]\n", + " [ 8.5227191e-05 -3.0336529e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[ 0.00042447 -0.00063165]\n", + " [-0.00081613 -0.00117288]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 741: Predicted: [[ 0.00032201 -0.00085804]\n", + " [ 0.00019875 -0.00088794]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 742: Predicted: [[ 0.00050544 -0.00024476]\n", + " [-0.0003472 -0.00094817]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[ 0.00019963 -0.00051384]\n", + " [-0.00027253 -0.00183064]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[ 1.6513141e-04 -7.7424973e-04]\n", + " [-6.9193542e-05 -7.4568391e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[-2.3265602e-04 -4.4127839e-04]\n", + " [ 3.4428835e-03 -2.5816262e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 746: Predicted: [[ 0.00040451 -0.00016066]\n", + " [-0.0012432 -0.0015619 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[-0.00033763 -0.00051631]\n", + " [ 0.00042831 -0.00054012]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 748: Predicted: [[ 0.00030348 -0.0005295 ]\n", + " [ 0.00022613 -0.00112908]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 749: Predicted: [[ 0.00018465 -0.00051575]\n", + " [-0.00052416 -0.00090599]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 750: Predicted: [[ 0.00039421 -0.00047601]\n", + " [-0.00052515 -0.0015521 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 751: Predicted: [[ 0.00053631 -0.00060766]\n", + " [-0.00071612 -0.00101891]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[-0.00024081 -0.00061504]\n", + " [-0.00019571 -0.00113571]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 753: Predicted: [[-0.00417438 0.0006872 ]\n", + " [ 0.01329878 0.5953788 ]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 754: Predicted: [[ 2.5080564e-04 -7.1901764e-04]\n", + " [ 8.4877014e-05 -6.3203275e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[ 2.1731341e-04 -6.0223421e-04]\n", + " [-9.9837780e-07 -7.5950474e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 756: Predicted: [[ 0.00025925 -0.00117802]\n", + " [ 0.00026731 -0.0008072 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[ 0.00033664 -0.0008712 ]\n", + " [ 0.00021854 -0.00069831]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[ 5.4656016e-04 -5.5822521e-04]\n", + " [-8.7074935e-05 -5.0055236e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[-0.00320685 -0.00334788]\n", + " [ 0.2616477 0.28042096]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 760: Predicted: [[ 0.0004027 -0.00041455]\n", + " [ 0.00016306 -0.0020713 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[ 4.8813759e-04 -4.9193500e-04]\n", + " [-1.8976629e-05 -5.7116151e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[ 0.00028709 -0.00034817]\n", + " [-0.00019719 -0.00148093]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[-0.00586856 -0.00399979]\n", + " [ 0.5093937 0.30398476]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 764: Predicted: [[ 0.00027432 -0.00102483]\n", + " [-0.00018592 -0.00043428]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 765: Predicted: [[ 0.00181371 -0.00557421]\n", + " [ 0.6080723 0.82349837]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 766: Predicted: [[ 9.505078e-05 -7.576440e-04]\n", + " [-7.390976e-05 -8.823350e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[ 4.0613418e-04 -5.2280276e-04]\n", + " [ 3.1448901e-05 -1.3817847e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 768: Predicted: [[ 0.00031838 0.00032463]\n", + " [-0.00115068 -0.00172752]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[ 0.00052519 -0.00066971]\n", + " [ 0.00044349 -0.00178985]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[ 0.00056526 -0.00064932]\n", + " [-0.00036871 -0.0008602 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 771: Predicted: [[ 0.00035141 -0.00076554]\n", + " [ 0.00048979 -0.00089007]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[ 8.2836021e-05 -1.0846846e-03]\n", + " [ 2.4672598e-04 -7.3242188e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[ 0.00018336 -0.0010267 ]\n", + " [-0.00095423 -0.00162399]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[-0.00013229 -0.00100781]\n", + " [ 0.00040565 -0.00141411]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[ 0.00055199 -0.00064498]\n", + " [-0.00062554 -0.00043572]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[ 2.6045367e-05 -7.7488465e-04]\n", + " [-7.0885569e-04 -1.6037375e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 777: Predicted: [[0.00099829 0.00383265]\n", + " [0.5873978 0.519891 ]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 778: Predicted: [[ 0.00043977 -0.0006797 ]\n", + " [-0.0006431 -0.00148584]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 779: Predicted: [[-2.7255621e-05 -9.3607610e-04]\n", + " [ 3.2337755e-04 -2.2869557e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 780: Predicted: [[-0.00120425 -0.00088711]\n", + " [ 0.34406596 0.837505 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 781: Predicted: [[-4.2391475e-05 -5.9742579e-04]\n", + " [-1.1635572e-04 -4.0580332e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[ 0.00035222 -0.00057217]\n", + " [-0.00057521 -0.00088237]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[ 6.8896916e-05 -8.2948949e-04]\n", + " [ 1.6173795e-03 4.8885122e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[ 0.00032476 -0.00056518]\n", + " [-0.00048084 -0.00097772]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[ 3.3461489e-04 6.3702784e-05]\n", + " [ 4.5376271e-04 -1.1829734e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 786: Predicted: [[ 1.0692375e-04 -8.5711066e-04]\n", + " [-7.8491867e-05 -7.9336017e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[0.00653961 0.0023492 ]\n", + " [0.08798958 0.0166291 ]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 788: Predicted: [[ 0.00016495 -0.00073028]\n", + " [-0.00045173 -0.00089657]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 789: Predicted: [[ 2.0429026e-05 -1.0170797e-03]\n", + " [-3.5916269e-04 -1.8478781e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 790: Predicted: [[ 0.00043751 -0.00055352]\n", + " [-0.00013743 -0.00081395]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[ 0.00027836 -0.00080463]\n", + " [ 0.00023656 -0.00071175]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 792: Predicted: [[ 0.000763 -0.00010788]\n", + " [ 0.00062867 -0.00105749]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 793: Predicted: [[ 3.7150458e-05 -7.1708002e-04]\n", + " [ 1.5711784e-04 -6.2059611e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[-8.5563269e-03 -1.8106174e-04]\n", + " [ 8.2669961e-01 5.2145302e-01]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 795: Predicted: [[-0.00424535 0.01072787]\n", + " [ 0.25590843 0.5797313 ]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 796: Predicted: [[ 0.00029718 -0.00069013]\n", + " [ 0.00041438 -0.00060575]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 797: Predicted: [[ 0.00069138 -0.00067004]\n", + " [ 0.00014406 -0.0010327 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 798: Predicted: [[ 0.00028162 -0.00065358]\n", + " [-0.00039548 -0.00070532]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 799: Predicted: [[ 0.00032146 -0.00064213]\n", + " [ 0.00020489 -0.00088939]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[ 0.00013837 -0.00061799]\n", + " [-0.0006797 -0.00096831]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 801: Predicted: [[ 0.00041647 -0.00011287]\n", + " [ 0.00030852 -0.0003142 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 802: Predicted: [[ 3.4603872e-04 -1.9831286e-04]\n", + " [-7.8663230e-05 -8.9248270e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[ 0.00024841 -0.00077744]\n", + " [ 0.00053562 -0.00083982]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[-0.00150288 -0.00364481]\n", + " [ 0.637228 0.40043697]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 805: Predicted: [[ 0.00020087 -0.00071795]\n", + " [-0.0005018 -0.00087119]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 806: Predicted: [[-0.00642233 -0.00677081]\n", + " [ 0.6182345 0.2082052 ]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 807: Predicted: [[ 0.00129983 -0.00235529]\n", + " [ 0.752758 0.748817 ]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 808: Predicted: [[ 2.5435351e-05 -8.2011166e-04]\n", + " [ 4.4575334e-04 -5.8089942e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 809: Predicted: [[-4.4690445e-05 -1.3476168e-04]\n", + " [ 4.8255920e-04 -1.2816116e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[-0.00019284 -0.00070042]\n", + " [ 0.00082831 -0.00050938]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[ 4.6787714e-04 -5.3722522e-04]\n", + " [-4.3660402e-06 -8.7882578e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[ 0.00016627 -0.00086437]\n", + " [-0.00013926 -0.00060847]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[ 7.2763767e-05 -4.8655272e-04]\n", + " [-6.9908798e-05 -1.4479905e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[ 0.00017242 -0.0008084 ]\n", + " [ 0.00012893 -0.00021651]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[ 4.4056214e-05 -7.1950798e-04]\n", + " [-1.9400567e-04 -6.8997592e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[ 0.00035039 -0.00089469]\n", + " [-0.00086045 -0.0016572 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[-1.5838211e-04 5.9454178e-06]\n", + " [ 9.9011511e-04 -1.5369356e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[-4.5910757e-04 -5.6105066e-04]\n", + " [ 4.8429665e-01 6.8754172e-01]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 819: Predicted: [[ 9.0137590e-05 -1.0069967e-03]\n", + " [ 6.9750100e-04 -1.8321276e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 820: Predicted: [[ 2.9680948e-04 -6.9728930e-04]\n", + " [-4.2483211e-05 -9.0950727e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[ 0.00066708 -0.00029037]\n", + " [-0.00059978 -0.00140983]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[ 0.00049186 -0.00067428]\n", + " [-0.00026853 -0.0009506 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 823: Predicted: [[ 0.00033752 -0.0009304 ]\n", + " [ 0.00027093 -0.0013257 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 824: Predicted: [[ 0.00017633 -0.00023332]\n", + " [-0.00016894 -0.00131729]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 825: Predicted: [[ 0.00040669 -0.00073842]\n", + " [-0.00106173 -0.00108945]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[ 0.00029449 -0.00064421]\n", + " [-0.0003609 -0.00150713]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[ 2.4451478e-04 -6.7095895e-04]\n", + " [-7.8424811e-05 -1.4001131e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[ 0.00028921 -0.00099488]\n", + " [ 0.00018252 0.00110469]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 829: Predicted: [[-3.0598603e-06 -9.3304930e-04]\n", + " [-5.3718686e-05 -1.2186468e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 830: Predicted: [[ 0.00022593 -0.00100319]\n", + " [-0.00033207 -0.00117099]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[-0.00174477 -0.00070299]\n", + " [ 0.26131612 0.42924622]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 832: Predicted: [[ 0.00010736 -0.00098834]\n", + " [ 0.00051071 -0.00104326]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[ 0.00034521 -0.00062764]\n", + " [-0.00086277 -0.0016827 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[ 0.00031684 -0.00083741]\n", + " [ 0.00059979 -0.00085675]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[ 3.7654303e-05 -5.7746988e-04]\n", + " [ 4.4406205e-04 -8.1206858e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 836: Predicted: [[ 0.00015481 -0.00089594]\n", + " [-0.00061397 -0.00072984]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[-8.0429018e-06 -9.5851679e-04]\n", + " [ 4.5954436e-04 -4.3615699e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 838: Predicted: [[ 0.00053168 -0.00057819]\n", + " [ 0.00030105 -0.00101356]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 839: Predicted: [[ 7.1716052e-04 1.3863319e-06]\n", + " [ 1.2755394e-05 -9.1172010e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 840: Predicted: [[ 2.4483935e-04 -7.4488012e-04]\n", + " [-9.5739961e-05 -1.1663660e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 841: Predicted: [[-0.00013373 -0.00085756]\n", + " [-0.00010216 -0.00071655]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[ 0.00030186 -0.00072034]\n", + " [ 0.00011434 0.00028123]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 843: Predicted: [[ 8.9487992e-05 -1.0429001e-03]\n", + " [-2.9202551e-04 -1.7351136e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 844: Predicted: [[ 2.5469624e-04 -1.0035280e-03]\n", + " [ 1.2069941e-05 2.1468103e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[ 0.00035462 -0.00074386]\n", + " [-0.00027916 -0.00140495]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[-0.00023954 -0.00094407]\n", + " [ 0.00091457 -0.00035957]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 847: Predicted: [[ 0.00013875 -0.00082948]\n", + " [ 0.0002135 -0.00091995]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[-0.00027136 -0.00069585]\n", + " [ 0.00257224 -0.00067474]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[ 6.0614315e-04 -3.6246353e-04]\n", + " [ 9.8340213e-05 -1.0357574e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 850: Predicted: [[ 4.3835654e-04 -7.7405822e-04]\n", + " [ 6.3158572e-05 -6.1044097e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[ 0.00037504 -0.0004758 ]\n", + " [ 0.00068093 -0.00113463]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[ 6.9070607e-05 -8.6288905e-04]\n", + " [ 1.3379008e-04 -7.3428452e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 853: Predicted: [[ 2.9718038e-05 -1.0518385e-03]\n", + " [-4.2608380e-04 -1.5480891e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 854: Predicted: [[ 0.00038435 -0.00077785]\n", + " [ 0.00010647 -0.00140688]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[-0.00025961 -0.00103453]\n", + " [ 0.00067455 -0.00140985]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[ 0.0003367 -0.0006339 ]\n", + " [-0.00033181 -0.00156217]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 857: Predicted: [[ 3.1311531e-05 -7.6643267e-04]\n", + " [-5.1822513e-04 -2.8666109e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 858: Predicted: [[ 9.9438708e-05 -7.6369528e-04]\n", + " [-1.5220791e-04 -7.6822937e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[ 0.00026147 -0.00036956]\n", + " [-0.0002647 -0.00103449]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 860: Predicted: [[0.00722143 0.00188585]\n", + " [0.78778887 0.75459665]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 861: Predicted: [[ 0.00014083 -0.00086733]\n", + " [ 0.00114495 -0.00047967]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[ 0.00029425 -0.00055554]\n", + " [ 0.00069252 -0.00143415]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[ 2.4418370e-04 -5.0386239e-04]\n", + " [-2.3573637e-05 -1.0536835e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[ 0.00039494 -0.00066586]\n", + " [-0.00037844 -0.00150807]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[ 0.00011488 -0.00062935]\n", + " [-0.0015195 -0.0014007 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 866: Predicted: [[ 3.1482778e-04 -9.8221097e-04]\n", + " [-6.6839159e-05 -1.7762184e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[ 0.00027723 -0.00061588]\n", + " [-0.00027318 -0.00064816]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 868: Predicted: [[ 7.7239238e-06 -6.7945564e-04]\n", + " [ 2.3111701e-05 -1.1122897e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[ 0.00044868 -0.00044173]\n", + " [-0.00050053 -0.00082543]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[ 0.00054799 -0.00051394]\n", + " [ 0.00031412 -0.00071172]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[ 3.4771790e-04 -7.8529184e-04]\n", + " [ 2.6725233e-05 -4.3365359e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[ 0.000186 -0.00074947]\n", + " [-0.00055175 -0.00071973]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[ 3.7476420e-06 -4.5752671e-04]\n", + " [-5.0001591e-04 -1.9493923e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 874: Predicted: [[ 0.00069746 -0.00042547]\n", + " [-0.00060993 -0.0013852 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 875: Predicted: [[-5.8406964e-05 -9.3678612e-04]\n", + " [ 7.2119385e-04 -1.1694282e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 876: Predicted: [[ 0.00010176 -0.00050106]\n", + " [-0.00023609 0.00011791]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[ 1.3958197e-05 -8.3424820e-04]\n", + " [-2.9206276e-06 -1.2839809e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 878: Predicted: [[ 0.00262161 -0.00160504]\n", + " [ 0.2821995 0.42323086]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 879: Predicted: [[ 0.0004966 -0.00011155]\n", + " [-0.00029768 -0.0012202 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 880: Predicted: [[ 0.00019439 -0.00019983]\n", + " [-0.00020792 -0.00044959]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[ 0.00046748 -0.00068573]\n", + " [-0.00031402 -0.00090373]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[ 0.00020675 -0.00092766]\n", + " [ 0.00031896 -0.00081746]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 883: Predicted: [[ 0.00054391 -0.00045426]\n", + " [-0.00063028 -0.00109161]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[-0.00045691 -0.00106554]\n", + " [ 0.00035266 0.00041344]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 885: Predicted: [[ 0.00070027 -0.00074685]\n", + " [ 0.000163 0.00043546]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 886: Predicted: [[ 0.00049762 -0.00056309]\n", + " [ 0.00023885 -0.00059097]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 887: Predicted: [[-6.4987224e-05 -7.7190768e-04]\n", + " [-6.0155243e-04 -1.2443885e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 888: Predicted: [[ 5.8870297e-05 -6.5893593e-04]\n", + " [ 1.4355034e-04 -1.0600835e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 889: Predicted: [[ 8.9303590e-05 -7.0122193e-04]\n", + " [ 4.0489435e-04 -7.1203709e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[ 0.00047702 -0.00069565]\n", + " [ 0.00015824 -0.00050228]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[ 0.00025071 -0.00084641]\n", + " [-0.00014771 -0.00017428]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[ 0.00044268 0.00104304]\n", + " [-0.00010169 -0.00030841]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[0.00086838 0.00260549]\n", + " [0.1307779 0.18007827]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 894: Predicted: [[ 6.6952314e-05 -8.7892363e-04]\n", + " [-1.8716604e-04 -4.9898028e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 895: Predicted: [[ 0.0001237 -0.00081494]\n", + " [-0.00048494 -0.00083347]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 896: Predicted: [[ 7.1310904e-05 -1.1201908e-03]\n", + " [ 3.8292259e-04 -8.1846863e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[ 3.2532867e-04 -7.9649739e-04]\n", + " [-7.1428716e-05 -8.4319711e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[ 0.00032143 -0.00075106]\n", + " [ 0.00024694 -0.00086585]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[ 0.00039462 -0.00057805]\n", + " [-0.00026697 -0.00124802]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[ 2.7147797e-04 -9.0605282e-04]\n", + " [-7.8402460e-05 -6.2058121e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 901: Predicted: [[ 0.00045685 -0.00044436]\n", + " [-0.00042492 -0.00131068]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[ 5.8006868e-04 -2.3755152e-04]\n", + " [ 7.0556998e-06 -1.2923405e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[-0.00191505 0.00473913]\n", + " [ 0.26960844 0.31545883]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 904: Predicted: [[ 0.00028493 -0.00068445]\n", + " [-0.00081603 -0.00145797]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[ 0.00021638 -0.00085607]\n", + " [ 0.00015754 -0.00096995]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[ 0.00012433 -0.00066366]\n", + " [-0.00011078 -0.00047124]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[ 1.1151750e-04 -9.5079531e-04]\n", + " [-4.2617321e-05 -1.6455203e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[ 0.00036504 -0.00064881]\n", + " [ 0.00019641 -0.00078398]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 909: Predicted: [[ 0.00053842 -0.00053656]\n", + " [-0.00027582 -0.00080518]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[-0.00199567 0.0007912 ]\n", + " [ 0.28015822 -0.00036546]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[-0.00220222 -0.00579797]\n", + " [ 0.2668769 0.34886384]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 912: Predicted: [[ 0.00047546 -0.00068201]\n", + " [-0.00026028 -0.00161687]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[ 5.2952231e-04 -5.8917620e-04]\n", + " [-9.6181035e-04 -9.0755522e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[ 0.00024855 -0.00088777]\n", + " [-0.00022066 -0.00057342]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[ 3.3732387e-04 -6.8747130e-04]\n", + " [ 6.3449144e-05 -6.3677877e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[ 0.00013249 -0.00082665]\n", + " [-0.00063247 -0.00063558]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 917: Predicted: [[ 0.00073224 -0.00019737]\n", + " [-0.00043108 -0.00114286]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 918: Predicted: [[-2.2249296e-06 -1.1809070e-03]\n", + " [ 3.8192421e-04 -1.0136813e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 919: Predicted: [[ 0.00034072 -0.00102727]\n", + " [-0.00039461 -0.00083227]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 920: Predicted: [[-0.00013696 -0.00035708]\n", + " [ 0.00624367 0.00698062]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 921: Predicted: [[ 1.7115707e-04 -1.0373499e-03]\n", + " [-6.4559281e-05 1.1309981e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 922: Predicted: [[ 0.00028001 -0.00062936]\n", + " [-0.00031509 -0.00135645]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 923: Predicted: [[ 0.00021243 -0.00070022]\n", + " [-0.00058022 -0.00173225]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 924: Predicted: [[ 3.6371849e-04 -7.7085575e-04]\n", + " [ 7.6219440e-06 -8.1510097e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[-0.00018536 -0.00088192]\n", + " [ 0.00013966 -0.00045774]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[ 0.00054128 -0.00044574]\n", + " [-0.00091714 -0.00128503]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[ 0.00041725 -0.000735 ]\n", + " [-0.00067338 -0.00102495]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 928: Predicted: [[-0.00031003 -0.00114482]\n", + " [ 0.00075889 -0.00145539]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[ 0.00026837 -0.00066998]\n", + " [-0.00092099 -0.00215142]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 930: Predicted: [[ 2.2226409e-04 -6.9600035e-04]\n", + " [ 4.1529536e-05 -1.8275976e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[ 0.0002386 -0.00068766]\n", + " [-0.00026434 -0.00090624]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[ 0.00048387 -0.00056357]\n", + " [-0.0003322 -0.00142318]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[ 3.2930495e-04 -2.6989967e-04]\n", + " [-2.8833747e-05 -1.1936799e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[ 0.00036606 -0.00061991]\n", + " [ 0.00031119 -0.00146132]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 935: Predicted: [[ 5.5261934e-04 -2.6114605e-04]\n", + " [-1.4893711e-05 -8.7821484e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[ 0.00028443 -0.0007741 ]\n", + " [-0.00015362 -0.00066677]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 937: Predicted: [[-0.00535103 0.00258035]\n", + " [ 0.27711517 0.3929784 ]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 938: Predicted: [[ 0.00068595 -0.00071318]\n", + " [-0.00041506 -0.00133453]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[ 6.3887332e-05 -8.9219207e-04]\n", + " [-3.5031885e-04 -3.6017597e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[ 0.00014643 -0.00069833]\n", + " [-0.00029659 -0.00125831]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 941: Predicted: [[ 0.00043153 -0.00057386]\n", + " [-0.0001367 -0.00128374]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 942: Predicted: [[ 3.0493829e-04 -6.1934086e-04]\n", + " [ 4.0195882e-05 -7.7176839e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[ 0.00025702 -0.0008901 ]\n", + " [ 0.000209 -0.00056106]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 944: Predicted: [[ 0.00058903 -0.00043218]\n", + " [-0.00042704 -0.00099266]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[-6.6492707e-05 -8.1627589e-04]\n", + " [ 7.8884512e-04 -1.0796562e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[ 0.00047654 -0.0006963 ]\n", + " [-0.00026268 -0.00128578]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[ 1.7119106e-05 -7.5741444e-04]\n", + " [ 3.5861135e-04 -9.4759464e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 948: Predicted: [[ 3.4489948e-04 -6.9523399e-04]\n", + " [ 9.5777214e-05 -7.7907741e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 949: Predicted: [[ 0.0003095 -0.00112777]\n", + " [ 0.00096114 -0.00125814]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[ 6.3396525e-05 -7.8531232e-04]\n", + " [ 6.6579878e-04 -1.0552704e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 951: Predicted: [[ 0.00027638 -0.00070089]\n", + " [-0.00043593 -0.0018289 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[ 0.00040745 -0.00041121]\n", + " [-0.00099766 -0.00145207]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 953: Predicted: [[ 2.0230189e-05 -1.0393909e-03]\n", + " [-4.6838820e-04 -6.7474693e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 954: Predicted: [[ 0.00014541 -0.00048224]\n", + " [ 0.00014134 -0.00096853]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[ 0.00023205 -0.00059903]\n", + " [-0.00103361 -0.00162437]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 956: Predicted: [[-0.00025323 -0.00098102]\n", + " [ 0.00156631 -0.00070046]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 957: Predicted: [[ 0.00031292 -0.00081406]\n", + " [ 0.00070934 -0.00084888]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[-5.5737048e-04 1.0420629e-03]\n", + " [ 7.8169167e-01 3.3737084e-01]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 959: Predicted: [[ 0.00032772 -0.00073468]\n", + " [ 0.00028958 -0.00088802]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[-0.00014829 -0.00064893]\n", + " [ 0.0001696 -0.00166354]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[ 2.8239144e-04 -5.7218556e-04]\n", + " [ 1.8246472e-05 -1.2208521e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 962: Predicted: [[ 0.00021171 -0.00048706]\n", + " [-0.00066997 -0.00080613]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[-1.6450742e-04 -7.2861958e-04]\n", + " [ 2.8334558e-05 -1.4033765e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 964: Predicted: [[ 0.00014925 -0.00088464]\n", + " [-0.00015444 -0.00078881]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 965: Predicted: [[-0.00857236 0.00508144]\n", + " [ 0.20508757 0.7575022 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 966: Predicted: [[ 1.8062582e-04 -8.7443023e-04]\n", + " [-3.0592084e-05 -6.5325201e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 967: Predicted: [[ 3.5395217e-04 -5.9274223e-04]\n", + " [ 6.7295134e-04 2.8327107e-05]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[-0.0015626 0.00077951]\n", + " [ 0.3441663 0.30557752]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 969: Predicted: [[0.01822305 0.01157287]\n", + " [0.04997919 0.46083522]], True: [[0. 0.75 ]\n", + " [0. 0.125]]\n", + "Tile 970: Predicted: [[-1.8550502e-04 -5.5043213e-04]\n", + " [-8.0905855e-05 -5.4100901e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[ 2.8465944e-04 6.0862803e-05]\n", + " [-8.8956207e-04 -1.0727569e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[ 0.00026495 -0.0007572 ]\n", + " [ 0.00032815 -0.00098165]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[ 0.00020467 -0.00058836]\n", + " [-0.00042327 -0.00191846]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 974: Predicted: [[-3.2350421e-05 -9.8480983e-04]\n", + " [-1.7977506e-04 -1.3899654e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[ 5.6539080e-04 -6.0089061e-04]\n", + " [-8.6493790e-05 -1.4202371e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 976: Predicted: [[ 0.00046941 -0.00025157]\n", + " [-0.00086013 -0.00152937]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[ 9.0553425e-05 -9.4783801e-04]\n", + " [-4.7738105e-04 -1.7184615e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 978: Predicted: [[ 8.0482103e-05 -1.0615494e-03]\n", + " [-5.0555915e-04 -7.6311082e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 979: Predicted: [[0.00440166 0.00038124]\n", + " [0.05837894 0.02055182]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 980: Predicted: [[ 0.00018934 -0.00040086]\n", + " [-0.00092185 -0.00182046]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[ 6.9407746e-05 -6.9020333e-04]\n", + " [-8.6612254e-04 -1.8900633e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 982: Predicted: [[ 0.00043458 -0.00079654]\n", + " [ 0.0005606 -0.00136226]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[0.00257117 0.00230938]\n", + " [0.01422328 0.15844417]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 984: Predicted: [[-9.7931828e-05 -6.5747794e-04]\n", + " [-1.2911782e-03 -9.0339780e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[ 0.00065075 -0.00031529]\n", + " [-0.00015004 -0.00098804]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[ 0.00028309 -0.00074395]\n", + " [ 0.00021318 -0.00105496]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 987: Predicted: [[ 1.2475997e-04 -7.2918570e-04]\n", + " [ 5.0559640e-05 -1.1164322e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 988: Predicted: [[ 0.00026401 -0.00051349]\n", + " [ 0.00069662 -0.00089335]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[ 0.00013693 -0.00082877]\n", + " [-0.00021787 -0.00089721]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[ 7.0075504e-05 -6.9229823e-04]\n", + " [-1.2432039e-04 -9.7983330e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[ 3.4452486e-04 -7.2645914e-04]\n", + " [-9.2461705e-06 -1.3544708e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 992: Predicted: [[ 0.00039533 -0.0004236 ]\n", + " [-0.00089307 0.00020831]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[ 5.8856793e-05 -9.0368890e-04]\n", + " [-2.0511448e-05 -5.1639974e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[ 0.00045652 -0.00076188]\n", + " [-0.00011937 -0.00068797]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 995: Predicted: [[ 0.00035794 -0.00065978]\n", + " [ 0.00012214 -0.00049609]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 996: Predicted: [[-4.9136579e-05 -8.5450482e-04]\n", + " [ 4.6402961e-04 -1.1107177e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[ 0.00037473 -0.00056782]\n", + " [-0.00028021 -0.00142442]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[ 0.00027072 -0.0006042 ]\n", + " [-0.00012653 -0.00128114]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[ 2.0289700e-04 -7.6466060e-04]\n", + " [-3.3073127e-05 -7.2970986e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[0.0111102 0.00938231]\n", + " [0.74126375 0.5777152 ]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 1001: Predicted: [[ 0.00048736 -0.00042325]\n", + " [ 0.00045691 -0.00218231]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1002: Predicted: [[ 0.0004896 -0.000651 ]\n", + " [ 0.00057664 -0.00096016]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[ 2.386421e-04 -6.781780e-04]\n", + " [ 6.198883e-05 -8.044541e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1004: Predicted: [[ 8.6984597e-05 -7.4523030e-04]\n", + " [ 2.3341924e-04 -1.3338402e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1005: Predicted: [[ 0.00061903 -0.0005469 ]\n", + " [-0.00022617 -0.00051346]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1006: Predicted: [[-0.00049166 -0.0010898 ]\n", + " [ 0.00106466 -0.00055049]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[ 0.00036904 -0.00068239]\n", + " [-0.00036343 -0.00118991]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1008: Predicted: [[ 0.00016039 -0.00069201]\n", + " [-0.00050286 -0.00057214]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1009: Predicted: [[-4.3860637e-06 -9.6057687e-04]\n", + " [-9.1751665e-04 -1.4266595e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[ 5.6889839e-05 -1.1616121e-03]\n", + " [ 4.8280507e-04 -8.4280223e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[ 0.00030615 -0.00058031]\n", + " [-0.00026506 -0.00092313]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1012: Predicted: [[-9.9923462e-05 -5.3264725e-04]\n", + " [-1.4772266e-04 -1.1522695e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[-4.6247123e-03 -1.2390019e-04]\n", + " [ 2.1832448e-01 5.1700336e-01]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 1014: Predicted: [[-0.00624285 -0.00274531]\n", + " [ 0.40523142 0.74209476]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 1015: Predicted: [[ 0.00213511 -0.01080894]\n", + " [ 0.33572343 0.3811084 ]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 1016: Predicted: [[ 0.0017715 -0.00120505]\n", + " [ 0.58480906 0.647503 ]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 1017: Predicted: [[ 8.4181782e-05 -7.9409516e-04]\n", + " [ 8.9988112e-05 -1.3957396e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[-0.00011743 -0.00076015]\n", + " [-0.00012659 -0.00092269]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1019: Predicted: [[ 0.00028538 -0.00047609]\n", + " [-0.00019102 -0.00118883]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1020: Predicted: [[ 0.00025039 -0.00089527]\n", + " [ 0.00030009 -0.0009167 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1021: Predicted: [[ 0.00026679 -0.00085319]\n", + " [-0.00030381 -0.00122736]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1022: Predicted: [[-0.00016494 -0.00086197]\n", + " [ 0.00082775 -0.00080195]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1023: Predicted: [[ 0.00013846 -0.0007575 ]\n", + " [-0.0002462 -0.00087982]], True: [[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "image_index = np.random.randint(0, 8) # Randomly pick an image in the batch\n", + "# image_index = 0\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 93\n", + "False Positives (FP): 15\n", + "False Negatives (FN): 5\n", + "Precision: 0.8611, Recall: 0.9490\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "\n", + "threshold = 0.8 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits): \n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1* tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 91\n", + "False Positives (FP): 17\n", + "False Negatives (FN): 7\n", + "Precision: 0.8426, Recall: 0.9286\n" + ] + } + ], + "source": [ + "\n", + "\n", + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.8\n", + "tile_size = 8\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " matched_true_hits = set()\n", + " matched_predictions = set()\n", + "\n", + " for pred_idx, pred in enumerate(valid_predicted_hits):\n", + " if pred_idx in matched_predictions:\n", + " continue\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 0.5 *tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " matched_predictions.add(pred_idx)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# # Example usage\n", + "# tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "# reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# # Plotting\n", + "# fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "# for i in range(4):\n", + "# ax[i].imshow(tiles[i], cmap='gray')\n", + "# ax[i].set_title(f\"Tile {i}\")\n", + "# ax[i].axis('off')\n", + "\n", + "# ax[4].imshow(reconstructed_image, cmap='gray')\n", + "# ax[4].set_title(\"Reconstructed Image\")\n", + "# ax[4].axis('off')\n", + "\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.8):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "c = np.random.randint(0,8)\n", + "image_index = c # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First image's first tile:\n", + "tf.Tensor(\n", + "[[0. ]\n", + " [0. ]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0. ]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0.00392157]], shape=(8, 1), dtype=float64)\n", + "First image's second tile:\n", + "tf.Tensor(\n", + "[[0. ]\n", + " [0. ]\n", + " [0.00784314]\n", + " [0.00392157]\n", + " [0.00784314]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0.00392157]], shape=(8, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "for val_images, val_centers in val_dataset.take(1):\n", + " print(\"First image's first tile:\")\n", + " print(val_images[2, 0]) # Tile 0 of Image 0\n", + " print(\"First image's second tile:\")\n", + " print(val_images[2, 1]) # Tile 1 of Image 0\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sod", + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/256 by 256 Training copy.ipynb b/Computer Vision_Object Detection/256 by 256 Training copy.ipynb new file mode 100644 index 0000000..88656c2 --- /dev/null +++ b/Computer Vision_Object Detection/256 by 256 Training copy.ipynb @@ -0,0 +1,4895 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 16:28:29.164301: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-22 16:28:29.176729: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-22 16:28:29.189528: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-22 16:28:29.193359: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-22 16:28:29.204231: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-22 16:28:29.840786: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:9',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 16:28:31.085941: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:cf:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"9\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:9\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def create_datasets(data_loader, train_size=0.95):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + " val_images_flat = val_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + "\n", + " # Flatten centers to match tiles\n", + " train_centers_flat = train_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + " val_centers_flat = val_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # Create TensorFlow datasets\n", + " batch_size = 128\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).shuffle(buffer_size=128, reshuffle_each_iteration=True).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/100Fixed_100_256by256_TestData_RandomindexNoNoise.h5' \n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0.25, 0.25],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,100)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " \"\"\"\n", + " Create a model that predicts hit locations for individual tiles.\n", + " \n", + " Parameters:\n", + " - input_shape: shape of the input tile (e.g., (8, 8, 1)).\n", + " - max_hits: maximum number of hits per tile (e.g., 2).\n", + "\n", + " Returns:\n", + " - model: The Keras model.\n", + " \"\"\"\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional and pooling layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + "\n", + " # Final dense layer for predictions\n", + " outputs = layers.Dense(max_hits * 2,activation='linear')(x)\n", + "\n", + " # Reshape output to match the target structure per tile\n", + " outputs = layers.Reshape((max_hits, 2))(outputs)\n", + "\n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((95, 1024, 8, 8), (5, 1024, 8, 8), (95, 1024, 2, 2), (5, 1024, 2, 2))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Check out this loss function AGAIN" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def split_mean_loss(y_true, y_pred):\n", + "# \"\"\"\n", + "# Custom loss function to separately calculate the loss for tiles with hits\n", + "# and empty tiles, explicitly comparing predictions to the GT for empty tiles.\n", + "# \"\"\"\n", + "# # Create a mask for tiles with hits (non-empty tiles)\n", + "# valid_mask = tf.reduce_any(y_true != 0, axis=-1, keepdims=True) # Shape: (batch_size, max_hits, 1)\n", + "\n", + "# # Loss for tiles with hits (valid tiles)\n", + "# valid_loss = tf.square(y_true - y_pred) * tf.cast(valid_mask, dtype=y_true.dtype)\n", + "# mean_valid_loss = tf.reduce_mean(valid_loss) # Mean loss over tiles with hits\n", + "\n", + "# # Loss for empty tiles (explicitly comparing predictions to y_true)\n", + "# empty_loss = tf.square(y_true - y_pred) * tf.cast(~valid_mask, dtype=y_pred.dtype)\n", + "# mean_empty_loss = tf.reduce_mean(empty_loss) # Mean loss over empty tiles\n", + "\n", + "# # Combine the two losses\n", + "# total_loss = mean_valid_loss + mean_empty_loss\n", + "\n", + "# return total_loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def refined_detection_loss_with_padding(y_true, y_pred):\n", + "# \"\"\"\n", + "# Custom loss function accounting for:\n", + "# - Valid hits (ignoring padding (0, 0)).\n", + "# - Empty tiles (penalizing false positives).\n", + "# \"\"\"\n", + "# # Create masks\n", + "# valid_mask = tf.reduce_any(y_true != 0, axis=-1, keepdims=True) # Non-empty tiles\n", + "# padding_mask = tf.reduce_all(y_true == 0, axis=-1, keepdims=True) # Identify padding entries\n", + "\n", + "# # Cast boolean masks to float32\n", + "# valid_mask_float = tf.cast(valid_mask, dtype=y_true.dtype)\n", + "# padding_mask_float = tf.cast(padding_mask, dtype=y_true.dtype)\n", + "\n", + "# # ========================\n", + "# # Loss for Tiles with Hits\n", + "# # ========================\n", + "# # Exclude padding (0, 0) in valid tiles\n", + "# valid_loss = tf.square(y_true - y_pred) * valid_mask_float * (1 - padding_mask_float)\n", + "# mean_valid_loss = tf.reduce_sum(valid_loss) / (tf.reduce_sum(valid_mask_float * (1 - padding_mask_float)) + 1e-6)\n", + "\n", + "# # =============================\n", + "# # Loss for Empty Tiles (No Hits)\n", + "# # =============================\n", + "# # Compare predictions to (0, 0) for empty tiles\n", + "# empty_target = tf.zeros_like(y_true) # Ground truth for empty tiles is (0, 0)\n", + "# empty_loss = tf.square(y_pred - empty_target) * padding_mask_float\n", + "# mean_empty_loss = tf.reduce_sum(empty_loss) / (tf.reduce_sum(padding_mask_float) + 1e-6)\n", + "\n", + "# # ========================\n", + "# # Combine the Two Losses\n", + "# # ========================\n", + "# valid_weight = 1.0 # Weight for valid tiles\n", + "# no_object_weight = 3.0 # Weight for empty tiles\n", + "\n", + "# total_loss = valid_weight * mean_valid_loss + no_object_weight * mean_empty_loss\n", + "\n", + "# return total_loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def hungarian_loss_for_two_hits_vectorized(y_true, y_pred):\n", + "# \"\"\"\n", + "# Permutation-invariant loss for a tile with up to 2 hits, vectorized version.\n", + " \n", + "# y_true, y_pred: (batch_size, 2, 2)\n", + "# - y_true[i] has up to 2 hits, with zero-padding for empty slots.\n", + "# - y_pred[i] is the model's 2 predicted points.\n", + "# Returns: scalar (averaged loss across the batch).\n", + "# \"\"\"\n", + "\n", + "# # 1) Identify how many hits per tile\n", + "# # row_nonzero[i,j] = True if y_true[i,j] != (0,0)\n", + "# row_nonzero = tf.reduce_any(tf.not_equal(y_true, 0.0), axis=-1) # (batch_size, 2)\n", + "# num_hits = tf.reduce_sum(tf.cast(row_nonzero, tf.float32), axis=-1) # (batch_size,), values ∈ {0,1,2}\n", + "\n", + "# # 2) Create masks for 0-hit, 1-hit, 2-hit tiles\n", + "# mask_0 = tf.equal(num_hits, 0.0) # (batch_size,)\n", + "# mask_1 = tf.equal(num_hits, 1.0) # (batch_size,)\n", + "# mask_2 = tf.equal(num_hits, 2.0) # (batch_size,)\n", + "\n", + "# mask_0_f = tf.cast(mask_0, tf.float32)\n", + "# mask_1_f = tf.cast(mask_1, tf.float32)\n", + "# mask_2_f = tf.cast(mask_2, tf.float32)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 0 HITS: Force both predicted points to be (0,0).\n", + "# # -------------------------------------------------------------------------\n", + "# # cost0[i] = sum of squares of y_pred[i], i.e. (pred1^2 + pred2^2)\n", + "# cost0 = tf.reduce_sum(tf.square(y_pred), axis=[1, 2]) # (batch_size,)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 2 HITS: Permutation-invariant cost.\n", + "# # -------------------------------------------------------------------------\n", + "# # cost_1 corresponds to (hit1→pred1, hit2→pred2)\n", + "# dist_1_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 0, :]), axis=-1)\n", + "# dist_1_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 1, :]), axis=-1)\n", + "# cost_1 = dist_1_1 + dist_1_2\n", + "\n", + "# # cost_2 corresponds to (hit1→pred2, hit2→pred1)\n", + "# dist_2_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 1, :]), axis=-1)\n", + "# dist_2_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 0, :]), axis=-1)\n", + "# cost_2 = dist_2_1 + dist_2_2\n", + "\n", + "# # Pick the smaller permutation cost\n", + "# cost2 = tf.minimum(cost_1, cost_2) # (batch_size,)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 1 HIT:\n", + "# # - Identify which row is the real hit (row0 or row1).\n", + "# # - Compute MSE for matching that hit to whichever predicted row is closer.\n", + "# # - Penalize the other predicted row for not being (0,0).\n", + "# # -------------------------------------------------------------------------\n", + "# row0_is_hit = row_nonzero[:, 0] # (batch_size,)\n", + "# # ground-truth single hit => either tile_true[:,0,:] or tile_true[:,1,:]\n", + "# gt_hit = tf.where(\n", + "# tf.expand_dims(row0_is_hit, axis=-1),\n", + "# y_true[:, 0, :],\n", + "# y_true[:, 1, :]\n", + "# ) # (batch_size, 2)\n", + "\n", + "# # Distances to each predicted point\n", + "# dist_pred_0 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 0, :]), axis=-1)\n", + "# dist_pred_1 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 1, :]), axis=-1)\n", + "\n", + "# # Also penalize the other row for not being near (0,0).\n", + "# zero_cost_0 = tf.reduce_sum(tf.square(y_pred[:, 0, :]), axis=-1)\n", + "# zero_cost_1 = tf.reduce_sum(tf.square(y_pred[:, 1, :]), axis=-1)\n", + "\n", + "# # Two ways to match:\n", + "# # -- pred_0 is the real hit => dist_pred_0 + zero_cost_1\n", + "# # -- pred_1 is the real hit => dist_pred_1 + zero_cost_0\n", + "# cost_if_0_matched = dist_pred_0 + zero_cost_1\n", + "# cost_if_1_matched = dist_pred_1 + zero_cost_0\n", + "# cost1 = tf.minimum(cost_if_0_matched, cost_if_1_matched) # (batch_size,)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # Combine costs across all tiles\n", + "# # For each tile i, only one of mask_0, mask_1, mask_2 is True.\n", + "# # -------------------------------------------------------------------------\n", + "# total_cost = mask_0_f * cost0 + mask_1_f * cost1 + mask_2_f * cost2\n", + "\n", + "# # Average over the batch\n", + "# loss = tf.reduce_mean(total_cost)\n", + "# return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "def sinkhorn_normalization(cost_matrix, num_iters=50, epsilon=1e-6):\n", + " \"\"\"Performs Sinkhorn normalization to approximate the doubly stochastic matrix.\"\"\"\n", + " for _ in range(num_iters):\n", + " cost_matrix -= tf.reduce_logsumexp(cost_matrix, axis=1, keepdims=True)\n", + " cost_matrix -= tf.reduce_logsumexp(cost_matrix, axis=0, keepdims=True)\n", + " return tf.exp(cost_matrix)\n", + "\n", + "def sinkhorn_loss(y_true, y_pred, epsilon=1e-6):\n", + " \"\"\"\n", + " Computes Sinkhorn loss using normalized doubly stochastic matrices.\n", + " \"\"\"\n", + " # Compute cost matrix (pairwise distances)\n", + " cost_matrix = tf.norm(tf.expand_dims(y_true, 1) - tf.expand_dims(y_pred, 0), axis=2)\n", + " \n", + " # Stabilize cost_matrix\n", + " cost_matrix = tf.clip_by_value(cost_matrix, epsilon, 1e6)\n", + " \n", + " # Apply Sinkhorn normalization\n", + " log_doubly_stochastic = sinkhorn_normalization(-cost_matrix)\n", + " \n", + " # Compute loss\n", + " loss = -tf.reduce_sum(log_doubly_stochastic * cost_matrix)\n", + " return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost Matrix:\n", + " [[0.25 0.25 ]\n", + " [0.3001666 0.3001666]]\n", + "Log Doubly Stochastic Matrix:\n", + " [[0.5 0.5]\n", + " [0.5 0.5]]\n", + "Sinkhorn Loss: 0.5501666\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "\n", + "# Define points\n", + "y_true = tf.constant([[0.25, 0.0], [0.3, 0.01]])\n", + "y_pred = tf.constant([[0.0, 0.0], [0., 0.0]])\n", + "\n", + "# Compute cost matrix\n", + "cost_matrix = tf.norm(tf.expand_dims(y_true, 1) - tf.expand_dims(y_pred, 0), axis=2)\n", + "\n", + "# Apply Sinkhorn normalization\n", + "log_doubly_stochastic = sinkhorn_normalization(-cost_matrix)\n", + "\n", + "# Compute Sinkhorn loss\n", + "loss = tf.reduce_sum(log_doubly_stochastic * cost_matrix)\n", + "\n", + "# Print results\n", + "print(\"Cost Matrix:\\n\", cost_matrix.numpy())\n", + "print(\"Log Doubly Stochastic Matrix:\\n\", log_doubly_stochastic.numpy())\n", + "print(\"Sinkhorn Loss:\", loss.numpy())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_1 (InputLayer)      │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (MaxPooling2D)  │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (Flatten)             │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (Dense)                 │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (Dense)                 │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape_1 (Reshape)             │ (None, 2, 2)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_1 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape_1 (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(optimizer = 'adam', loss= sinkhorn_loss) \n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<_BatchDataset element_spec=(TensorSpec(shape=(None, 8, 8, 1), dtype=tf.float64, name=None), TensorSpec(shape=(None, 2, 2), dtype=tf.float64, name=None))>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 16:32:48.636769: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m759/760\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 20ms/step - loss: -75954616.0000" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 16:33:08.552014: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "W0000 00:00:1737581589.236326 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.240565 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.240905 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.241184 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.241534 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.241819 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.242080 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.242342 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.242733 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.243007 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.243330 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.243609 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.243923 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.244245 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737581589.244537 2772948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m760/760\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 21ms/step - loss: -76197600.0000 - val_loss: -256000000.0000 - learning_rate: 0.0010\n", + "Epoch 2/10\n", + "\u001b[1m 5/760\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m9s\u001b[0m 13ms/step - loss: -256000000.0000 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 16:33:09.843569: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m759/760\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 20ms/step - loss: -256000000.0000" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 16:33:25.221311: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m760/760\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 21ms/step - loss: -256000000.0000 - val_loss: -256000000.0000 - learning_rate: 0.0010\n", + "Epoch 3/10\n", + "\u001b[1m 1/760\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:33\u001b[0m 123ms/step - loss: -256000000.0000" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 16:33:25.644617: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m236/760\u001b[0m \u001b[32m━━━━━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━\u001b[0m \u001b[1m10s\u001b[0m 20ms/step - loss: -256000000.0000" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mlr_scheduler\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py:117\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 115\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 117\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 118\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 119\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py:318\u001b[0m, in \u001b[0;36mTensorFlowTrainer.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq)\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m step, iterator \u001b[38;5;129;01min\u001b[39;00m epoch_iterator\u001b[38;5;241m.\u001b[39menumerate_epoch():\n\u001b[1;32m 317\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m--> 318\u001b[0m logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 319\u001b[0m logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pythonify_logs(logs)\n\u001b[1;32m 320\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_end(step, logs)\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:833\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 830\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 832\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 833\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 835\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 836\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:878\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 875\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[1;32m 876\u001b[0m \u001b[38;5;66;03m# In this case we have not created variables on the first call. So we can\u001b[39;00m\n\u001b[1;32m 877\u001b[0m \u001b[38;5;66;03m# run the first trace but we should fail if variables are created.\u001b[39;00m\n\u001b[0;32m--> 878\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 879\u001b[0m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_variable_creation_config\u001b[49m\n\u001b[1;32m 880\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 881\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_created_variables:\n\u001b[1;32m 882\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCreating variables on a non-first call to a function\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 883\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m decorated with tf.function.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[0;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[1;32m 137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[0;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[1;32m 140\u001b[0m \u001b[43m \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[1;32m 141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py:1322\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[1;32m 1318\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1319\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1320\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1321\u001b[0m \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1322\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1323\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1324\u001b[0m args,\n\u001b[1;32m 1325\u001b[0m possible_gradient_type,\n\u001b[1;32m 1326\u001b[0m executing_eagerly)\n\u001b[1;32m 1327\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m 214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m 215\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 216\u001b[0m flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 217\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[1;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[0;32m--> 251\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 252\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 253\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 257\u001b[0m outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[1;32m 258\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 259\u001b[0m \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[1;32m 260\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[1;32m 261\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/eager/context.py:1552\u001b[0m, in \u001b[0;36mContext.call_function\u001b[0;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[1;32m 1550\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[1;32m 1551\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1552\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1553\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1554\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1555\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1556\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1557\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1558\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1559\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1560\u001b[0m outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 1561\u001b[0m name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 1562\u001b[0m num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1566\u001b[0m cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[1;32m 1567\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/eager/execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 52\u001b[0m ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 53\u001b[0m tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=10,\n", + " \n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/Jan 21 weights/30KFixed_100_256by256_RandomindexNoNoise.h5_linear_custom_HungarianLoss.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/Jan 21 weights/30KFixed_100_256by256_RandomindexNoNoise.h5_linear_custom_HungarianLoss.keras')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/1600\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m8:06\u001b[0m 304ms/step" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:05:55.575215: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1737576355.623856 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.642286 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.647923 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.648188 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.648406 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.648610 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.648820 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.649954 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.650174 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.650380 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.651632 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.652752 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.653971 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.659074 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.660359 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.669568 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.670699 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.671874 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.673214 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.674434 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.675642 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.680714 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576355.680975 2645428 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1600/1600\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 761us/step\n", + "Predicted centers shape: (50, 1024, 2, 2)\n", + "Grouped targets shape: (50, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "# # # # Flatten validation images and centers\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "\n", + "# Batch size for n images\n", + "batch = 50* 1024 # number of images per batch\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch)\n", + "# Make predictions on dataset\n", + "# inputs, targets = next(iter(val_dataset)) # Extract a batch\n", + "inputs, targets = next(iter(train_dataset)) # Extract a batch\n", + "outputs = loaded_model.predict(inputs)\n", + "\n", + "# Reshape predictions and targets back to image structure\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 2)\n", + "\n", + "# Print the shapes\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\") # (batch_size // 1024, 1024, 2, 2)\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\") # (batch_size // 1024, 1024, 2, 2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 1:\n", + "Tile 0: Predicted: [[-0.00372641 0.00091963]\n", + " [ 0.26896513 0.16465415]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 1: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 4: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 5: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 6: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 7: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 11: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 18: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 23: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 24: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[ 0.0034274 -0.00146852]\n", + " [ 0.14659469 0.48926523]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 28: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 29: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 30: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 31: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[0.00393006 0.00170477]\n", + " [0.00217469 0.20110728]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 34: Predicted: [[ 0.00845006 -0.01470136]\n", + " [ 0.34015626 0.6599338 ]], True: [[0.5 0.875]\n", + " [0. 0. ]]\n", + "Tile 35: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 37: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 38: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 44: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 46: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[ 0.00837627 -0.01952522]\n", + " [ 0.6132632 0.72548157]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 48: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 49: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 51: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 53: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 55: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[0.07700749 0.00938728]\n", + " [0.02441537 0.5645052 ]], True: [[0.25 0. ]\n", + " [0.125 0.75 ]]\n", + "Tile 59: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[ 0.01777016 -0.01940544]\n", + " [ 0.23604283 0.7477545 ]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 61: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 63: Predicted: [[0.00777106 0.00783385]\n", + " [0.7119284 0.37232947]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 64: Predicted: [[0.0113178 0.01064734]\n", + " [0.83655834 0.5083477 ]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 65: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 66: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 67: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 68: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 69: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 71: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 73: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 76: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 77: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 80: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 85: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 86: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 87: Predicted: [[ 0.00368329 -0.00383119]\n", + " [ 0.16180499 0.5342321 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 88: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 90: Predicted: [[0.00670112 0.00483402]\n", + " [0.00448665 0.17268218]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 91: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 92: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 93: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 95: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 96: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 98: Predicted: [[ 4.2371079e-03 -2.2043008e-05]\n", + " [ 5.7569569e-01 7.4564725e-01]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 99: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 100: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 102: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 103: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 106: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 108: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 111: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 112: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 113: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 114: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 118: Predicted: [[-0.00699816 -0.00119631]\n", + " [ 0.39128643 0.38295615]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 119: Predicted: [[ 5.0126191e-04 4.8107468e-06]\n", + " [ 1.5881898e-01 -8.2597928e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 120: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 122: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 124: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[ 0.00864154 -0.00581122]\n", + " [ 0.24767384 0.7624619 ]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 126: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 127: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 129: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 131: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 134: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[ 0.01057474 -0.00179412]\n", + " [ 0.0556946 0.70441264]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 140: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 141: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 142: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 143: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 145: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[0.00702687 0.00916526]\n", + " [0.00235687 0.6002739 ]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 147: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 149: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 151: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 155: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 160: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 161: Predicted: [[0.01667215 0.01253566]\n", + " [0.7431159 0.738274 ]], True: [[0.75 0.625]\n", + " [0. 0. ]]\n", + "Tile 162: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 164: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 165: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 166: Predicted: [[0.02350166 0.01289662]\n", + " [0.65892446 0.66158324]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 167: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 169: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 171: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 172: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 174: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 179: Predicted: [[0.01644349 0.00225064]\n", + " [0.59688807 0.1504639 ]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 180: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 182: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 184: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[-0.0039839 0.01349409]\n", + " [ 0.5035178 0.39859107]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 186: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 188: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 190: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 192: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 194: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 196: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 198: Predicted: [[ 0.0182216 0.37598974]\n", + " [ 0.6954719 -0.03674339]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 199: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 201: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 202: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 205: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 206: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 207: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 210: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 211: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 212: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 213: Predicted: [[-0.00100662 -0.00375083]\n", + " [ 0.34954426 0.2137786 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 214: Predicted: [[0.00578149 0.00245363]\n", + " [0.01243142 0.42733344]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 215: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 216: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 217: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 218: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 219: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 220: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 222: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 225: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 226: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 227: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 228: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 230: Predicted: [[ 0.00201056 -0.00053254]\n", + " [ 0.09301858 0.00361132]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 231: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 234: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 236: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 237: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 238: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 239: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 240: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 241: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 242: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 244: Predicted: [[0.01345341 0.00938007]\n", + " [0.41314748 0.6179342 ]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 245: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 246: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 247: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 249: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 253: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 254: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 255: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 257: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 258: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 259: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 262: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 264: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 266: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 267: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 268: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[0.0037659 0.00817588]\n", + " [0.75765014 0.32475185]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 272: Predicted: [[-0.01745926 0.24042523]\n", + " [ 0.85563326 0.26877642]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 273: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 274: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 278: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 279: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 280: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 281: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 283: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 284: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 286: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 287: Predicted: [[-0.00461004 0.00158812]\n", + " [ 0.34965873 0.28102544]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 288: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 290: Predicted: [[0.01143731 0.0021105 ]\n", + " [0.5156781 0.7817364 ]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 291: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 292: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 293: Predicted: [[-0.01133476 -0.00930733]\n", + " [ 0.7311009 0.64517313]], True: [[0.75 0.625]\n", + " [0. 0. ]]\n", + "Tile 294: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 295: Predicted: [[0.01335677 0.01430393]\n", + " [0.71876943 0.8539242 ]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 296: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 297: Predicted: [[0.00457824 0.00519749]\n", + " [0.2862072 0.29802966]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 298: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 299: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 300: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 302: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 303: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 304: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 305: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 307: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[ 4.7267217e-04 -3.2822867e-03]\n", + " [ 1.2850024e-01 4.8971173e-01]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 309: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 310: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 311: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 313: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 314: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 315: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 317: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 318: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 320: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 321: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 325: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 328: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[-0.00095749 0.00488777]\n", + " [ 0.72035414 0.01165394]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 330: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 333: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 334: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 336: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 337: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 338: Predicted: [[0.00139474 0.00277824]\n", + " [0.38531503 0.13340618]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 339: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 340: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 342: Predicted: [[0.00547083 0.00455184]\n", + " [0.4304989 0.49910876]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 344: Predicted: [[0.00101356 0.00032836]\n", + " [0.00321071 0.00427705]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 345: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 347: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[0.03347421 0.04078554]\n", + " [0.2644943 0.4650579 ]], True: [[0.25 0.375]\n", + " [0.375 0.625]]\n", + "Tile 349: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 350: Predicted: [[0.23786135 0.15496524]\n", + " [0.71940386 0.17004421]], True: [[0.25 0.25]\n", + " [0.75 0.25]]\n", + "Tile 351: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 353: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 354: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 355: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 356: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[-0.00097941 -0.00193542]\n", + " [ 0.25441456 0.269507 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 362: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[2.8538785e-04 7.8945998e-03]\n", + " [7.3247617e-01 5.4103321e-01]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 365: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 366: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 367: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 369: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 370: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 371: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 372: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 374: Predicted: [[-0.00611688 -0.00520942]\n", + " [ 0.36213964 0.01692337]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 375: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 378: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[0.04246917 0.11649813]\n", + " [0.5251544 0.782653 ]], True: [[0.125 0.125]\n", + " [0.625 0.875]]\n", + "Tile 380: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 381: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 382: Predicted: [[ 3.0463263e-03 -7.0075039e-05]\n", + " [-8.1331879e-03 3.9387232e-01]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 383: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 384: Predicted: [[0.03174198 0.03585132]\n", + " [0.5442527 0.7032856 ]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 385: Predicted: [[0.00201048 0.00591509]\n", + " [0.7371122 0.045542 ]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 386: Predicted: [[-0.0015772 0.00039534]\n", + " [ 0.31913567 0.08364151]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[0.00351921 0.00339415]\n", + " [0.01221562 0.10190511]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 388: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 389: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[-0.00133181 0.00052145]\n", + " [ 0.3962334 0.01054059]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 393: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 395: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 396: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 397: Predicted: [[0.01217257 0.01284738]\n", + " [0.7745869 0.6575091 ]], True: [[0.75 0.75]\n", + " [0. 0. ]]\n", + "Tile 398: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 399: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[0.00391768 0.00464551]\n", + " [0.25055483 0.2575567 ]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 405: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 407: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 408: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 411: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 412: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 414: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 416: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[0.00771745 0.01054453]\n", + " [0.24575943 0.6204073 ]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 419: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 423: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 424: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 425: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 429: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 437: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 441: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 443: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 449: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 451: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 453: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 454: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 457: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 458: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 459: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 460: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 462: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 466: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 467: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 468: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 469: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 470: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 471: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 472: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 478: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 481: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 482: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 483: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[ 2.1485600e-04 -5.7595787e-03]\n", + " [ 6.7743742e-01 4.8936397e-01]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 486: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 487: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 490: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 492: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 493: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 495: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 496: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 497: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[0.00340908 0.0026612 ]\n", + " [0.14245866 0.37352243]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 499: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 500: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[0.00413977 0.01075016]\n", + " [0.2374753 0.38709638]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 505: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[0.00574963 0.00553801]\n", + " [0.12664871 0.12290819]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 507: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 509: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 512: Predicted: [[-0.00027946 0.00042236]\n", + " [ 0.17827873 0.09284062]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 513: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 517: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[-0.00258816 0.0042017 ]\n", + " [ 0.30539784 0.34242612]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 519: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 522: Predicted: [[-0.01092861 0.05372695]\n", + " [ 0.07674659 0.41701317]], True: [[0. 0.5 ]\n", + " [0.75 0.875]]\n", + "Tile 523: Predicted: [[0.0084804 0.0023631 ]\n", + " [0.12191083 0.72410357]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 524: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 526: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 529: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 530: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 535: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 536: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 538: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 542: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 543: Predicted: [[0.01115908 0.00717767]\n", + " [0.6130521 0.61401075]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 544: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 548: Predicted: [[0.00811181 0.00714528]\n", + " [0.2548143 0.34416956]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 549: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 552: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 554: Predicted: [[1.38813339e-03 1.13315415e-04]\n", + " [4.63311970e-01 4.97725839e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 556: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 558: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 560: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 561: Predicted: [[0.00630633 0.00966808]\n", + " [0.6354783 0.37508804]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 562: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 563: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 565: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 566: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 567: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 568: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 569: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 570: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 571: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 572: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 579: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[ 0.00544338 -0.00359058]\n", + " [ 0.3361913 0.13432835]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 582: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 583: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 584: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 585: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 590: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 592: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 594: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 596: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 597: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 598: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 600: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 602: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 603: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 604: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 605: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 606: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 608: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 609: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 610: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 613: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 617: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 618: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 619: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 620: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 622: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 623: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 625: Predicted: [[0.00154676 0.00448594]\n", + " [0.0091092 0.5454429 ]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 626: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 627: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 628: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[ 0.00162297 -0.00278777]\n", + " [ 0.00429394 0.43126372]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 633: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 634: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 635: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 641: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 642: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 643: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 645: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[-0.00418137 -0.01252787]\n", + " [ 0.11695084 0.27376252]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 647: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 648: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 649: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 650: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 651: Predicted: [[ 0.00169853 -0.00683946]\n", + " [ 0.70530677 0.5640865 ]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 652: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 653: Predicted: [[0.01779272 0.16386187]\n", + " [0.23214951 0.5991756 ]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 654: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[-0.00489094 -0.00092248]\n", + " [ 0.63118076 0.3382206 ]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 657: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 659: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 660: Predicted: [[-0.00199757 0.00262645]\n", + " [ 0.25970444 0.00393101]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[0.0011742 0.00098229]\n", + " [0.00092422 0.0004564 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 662: Predicted: [[0.00274253 0.00433032]\n", + " [0.25568065 0.16739133]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 663: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[0.00178001 0.00138711]\n", + " [0.44640198 0.44294763]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 667: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 674: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[0.00614042 0.00068207]\n", + " [0.2684998 0.00955179]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 676: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 677: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[ 0.00433721 -0.0012015 ]\n", + " [ 0.32110554 0.00700478]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 679: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 688: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 693: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 694: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 695: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 698: Predicted: [[-0.00484833 0.01001989]\n", + " [ 0.5653007 0.03001962]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 699: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 700: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 701: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[0.01587202 0.00895367]\n", + " [0.34604245 0.7501353 ]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 705: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 706: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 708: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 710: Predicted: [[0.00865769 0.00554503]\n", + " [0.11669843 0.37439537]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 711: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 712: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 713: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 715: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 716: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 717: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 718: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 722: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 723: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 724: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 726: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 727: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 729: Predicted: [[0.00296453 0.0036502 ]\n", + " [0.5058184 0.22340767]], True: [[0.5 0.125]\n", + " [0. 0. ]]\n", + "Tile 730: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 731: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[-0.01699212 -0.02348252]\n", + " [ 0.4926571 0.40803167]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 733: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 734: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 735: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[0.01717651 0.00529314]\n", + " [0.21661544 0.7564158 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[0.00561666 0.00597084]\n", + " [0.7397871 0.49349415]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 741: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 742: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 746: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 748: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 749: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 750: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 751: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 753: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 754: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 756: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 760: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 764: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 765: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 766: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 768: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 771: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 777: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 778: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 779: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 780: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 781: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 786: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 788: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 789: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 790: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[0.00890873 0.01217919]\n", + " [0.24537352 0.62118435]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 792: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 793: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 795: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 796: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 797: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 798: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 799: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 801: Predicted: [[0.00340349 0.01195675]\n", + " [0.7156778 0.45396802]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 802: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 805: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 806: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 807: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 808: Predicted: [[ 0.00363413 -0.00428413]\n", + " [ 0.34645778 0.14083718]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 809: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 819: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 820: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 823: Predicted: [[0.00839861 0.00228122]\n", + " [0.12582748 0.24194065]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 824: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 825: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 829: Predicted: [[0.0246486 0.01509411]\n", + " [0.32502288 0.44216815]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 830: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 832: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 836: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[0.00748039 0.00185063]\n", + " [0.10146971 0.6958481 ]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 838: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 839: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 840: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 841: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 843: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 844: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 847: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[ 0.00092924 -0.00447576]\n", + " [ 0.7752089 0.63353163]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 850: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 853: Predicted: [[0.01603179 0.01807283]\n", + " [0.6548436 0.61769557]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 854: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[ 0.00100346 -0.00232487]\n", + " [ 0.07721082 0.1104966 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[ 0.00250458 -0.00317088]\n", + " [ 0.39186075 0.4321599 ]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 857: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 858: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 860: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 861: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 866: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 868: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 874: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 875: Predicted: [[0.00547618 0.00587853]\n", + " [0.74590147 0.41473585]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 876: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 878: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 879: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 880: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 883: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 885: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 886: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 887: Predicted: [[-0.00581388 -0.00858321]\n", + " [ 0.6114321 0.01233804]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 888: Predicted: [[0.16963124 0.07034244]\n", + " [0.6508787 0.39666116]], True: [[0.5 0.125]\n", + " [0.875 0.875]]\n", + "Tile 889: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 894: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 895: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 896: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 901: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 904: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 909: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 912: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 917: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 918: Predicted: [[ 0.00381493 -0.00437875]\n", + " [ 0.744052 0.3234111 ]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 919: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 920: Predicted: [[-0.0009409 0.00067102]\n", + " [ 0.48573682 0.01069679]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 921: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 922: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 923: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 924: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 928: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 930: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[0.00768822 0.00351409]\n", + " [0.12952194 0.6843321 ]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 935: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 937: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 938: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 941: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 942: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 944: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[ 0.01173802 0.00989529]\n", + " [-0.00127345 0.5845882 ]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 948: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 949: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 951: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 953: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 954: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 956: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 957: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 959: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 962: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 964: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 965: Predicted: [[ 0.00079526 -0.00380096]\n", + " [ 0.3980338 0.33959088]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 966: Predicted: [[0.0093555 0.01184943]\n", + " [0.00752427 0.6147001 ]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 967: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 969: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 970: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[0.00369492 0.00507816]\n", + " [0.27083385 0.2825939 ]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 974: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 976: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 978: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 979: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 980: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[0.01130281 0.00615195]\n", + " [0.24784078 0.6103016 ]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 982: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 984: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 987: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 988: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 992: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[ 0.00158581 -0.00071844]\n", + " [ 0.11590093 0.2928749 ]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 995: Predicted: [[0.00608916 0.01317541]\n", + " [0.53666145 0.2556825 ]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 996: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1001: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1002: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[0.03116364 0.02638191]\n", + " [0.50115716 0.62375796]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 1004: Predicted: [[0.01220623 0.01209493]\n", + " [0.30747855 0.68534845]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 1005: Predicted: [[-0.01129432 0.00146979]\n", + " [ 0.24599387 -0.00039589]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1006: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1008: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1009: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1012: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1014: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1015: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1016: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1017: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1019: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1020: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1021: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1022: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1023: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "image_index = np.random.randint(0, 50) # Randomly pick an image in the batch\n", + "# image_index = 0\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize counters for recomputed statistics\n", + "zero_hit_correct = 0\n", + "zero_hit_total = 0\n", + "\n", + "one_hit_correct = 0\n", + "one_hit_total = 0\n", + "\n", + "two_hit_correct = 0\n", + "two_hit_total = 0\n", + "\n", + "# Error accumulators\n", + "zero_hit_errors = []\n", + "one_hit_errors = []\n", + "two_hit_errors = []\n", + "\n", + "# Recompute metrics with direct comparison to ground truth\n", + "for i in range(predicted_centers.shape[0]): # Batch size\n", + " for j in range(predicted_centers.shape[1]): # Tiles per image\n", + " # True and predicted hits for the current tile\n", + " true_hits = grouped_targets[i, j]\n", + " pred_hits = predicted_centers[i, j]\n", + "\n", + " # Count non-zero hits\n", + " true_nonzero = np.any(true_hits != 0, axis=-1)\n", + " num_true_hits = np.sum(true_nonzero)\n", + "\n", + " # Case: 0 hits\n", + " if num_true_hits == 0:\n", + " zero_hit_total += 1\n", + " if np.allclose(pred_hits, 0, atol=0.1): # Predictions close to (0, 0)\n", + " zero_hit_correct += 1\n", + " zero_hit_errors.append(np.linalg.norm(pred_hits))\n", + "\n", + " # Case: 1 hit\n", + " elif num_true_hits == 1:\n", + " one_hit_total += 1\n", + " true_hit = true_hits[true_nonzero][0]\n", + " pred_distances = np.linalg.norm(pred_hits - true_hit, axis=-1)\n", + " closest_pred = np.argmin(pred_distances)\n", + "\n", + " if pred_distances[closest_pred] < 0.1: # Correct if close enough\n", + " one_hit_correct += 1\n", + "\n", + " one_hit_errors.append(pred_distances[closest_pred])\n", + "\n", + " # Case: 2 hits\n", + " elif num_true_hits == 2:\n", + " two_hit_total += 1\n", + " dist_1 = np.linalg.norm(true_hits[0] - pred_hits[0]) + np.linalg.norm(true_hits[1] - pred_hits[1])\n", + " dist_2 = np.linalg.norm(true_hits[0] - pred_hits[1]) + np.linalg.norm(true_hits[1] - pred_hits[0])\n", + "\n", + " error = min(dist_1, dist_2)\n", + " if error < 0.1: # Correct if permutation invariant\n", + " two_hit_correct += 1\n", + "\n", + " two_hit_errors.append(error)\n", + "\n", + "# Compute accuracy for each case\n", + "zero_hit_accuracy = zero_hit_correct / zero_hit_total if zero_hit_total > 0 else 0\n", + "one_hit_accuracy = one_hit_correct / one_hit_total if one_hit_total > 0 else 0\n", + "two_hit_accuracy = two_hit_correct / two_hit_total if two_hit_total > 0 else 0\n", + "\n", + "# Compute average error for each case\n", + "avg_zero_hit_error = np.mean(zero_hit_errors) if zero_hit_errors else 0\n", + "avg_one_hit_error = np.mean(one_hit_errors) if one_hit_errors else 0\n", + "avg_two_hit_error = np.mean(two_hit_errors) if two_hit_errors else 0\n", + "\n", + "# Visualization of recomputed statistics\n", + "labels = ['0 Hits', '1 Hit', '2 Hits']\n", + "accuracies = [zero_hit_accuracy, one_hit_accuracy, two_hit_accuracy]\n", + "avg_errors = [avg_zero_hit_error, avg_one_hit_error, avg_two_hit_error]\n", + "\n", + "# Plot recomputed accuracy\n", + "plt.figure(figsize=(12, 6))\n", + "plt.bar(labels, accuracies, alpha=0.7, color='blue', edgecolor='black')\n", + "plt.title(\"Recomputed Prediction Accuracy by Case\", fontsize=14)\n", + "plt.ylabel(\"Accuracy\", fontsize=12)\n", + "plt.xlabel(\"Case\", fontsize=12)\n", + "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + "plt.show()\n", + "\n", + "# Plot recomputed average error\n", + "plt.figure(figsize=(12, 6))\n", + "plt.bar(labels, avg_errors, alpha=0.7, color='orange', edgecolor='black')\n", + "plt.title(\"Recomputed Average Error by Case\", fontsize=14)\n", + "plt.ylabel(\"Average Error (Distance)\", fontsize=12)\n", + "plt.xlabel(\"Case\", fontsize=12)\n", + "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Case Average Pixel Offset\n", + "0 0 Hits 0.008384\n", + "1 1 Hit 0.129232\n", + "2 2 Hits 0.437433\n" + ] + } + ], + "source": [ + "# Compute pixel-level error for each case\n", + "avg_pixel_error_zero_hit = np.mean(zero_hit_errors) if zero_hit_errors else 0\n", + "avg_pixel_error_one_hit = np.mean(one_hit_errors) if one_hit_errors else 0\n", + "avg_pixel_error_two_hit = np.mean(two_hit_errors) if two_hit_errors else 0\n", + "\n", + "# Summarize the results\n", + "pixel_error_summary = {\n", + " \"0 Hits\": avg_pixel_error_zero_hit,\n", + " \"1 Hit\": avg_pixel_error_one_hit,\n", + " \"2 Hits\": avg_pixel_error_two_hit,\n", + "}\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create a DataFrame to display the summary\n", + "error_df = pd.DataFrame.from_dict(\n", + " pixel_error_summary, orient='index', columns=[\"Average Pixel Offset\"]\n", + ")\n", + "error_df.index.name = \"Case\"\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create a DataFrame for better visualization\n", + "pixel_error_summary = {\n", + " \"Case\": [\"0 Hits\", \"1 Hit\", \"2 Hits\"],\n", + " \"Average Pixel Offset\": [avg_pixel_error_zero_hit, avg_pixel_error_one_hit, avg_pixel_error_two_hit]\n", + "}\n", + "\n", + "# Convert to a pandas DataFrame\n", + "error_df = pd.DataFrame(pixel_error_summary)\n", + "\n", + "# Print the DataFrame\n", + "print(error_df)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution of hits across all tiles:\n", + "0 hits: 92999\n", + "1 hits: 8963\n", + "2 hits: 438\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# After you load and normalize the data\n", + "normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# Flatten to tile-level\n", + "num_images = normalized_centers.shape[0] # how many big images\n", + "num_tiles = normalized_centers.shape[1] # tiles per image, e.g. 256*256 / (8*8) = 1024\n", + "max_hits = normalized_centers.shape[2] # 2\n", + "_ = normalized_centers.shape[3] # 2 coords\n", + "\n", + "num_hits_distribution = {0: 0, 1: 0, 2: 0}\n", + "\n", + "for i in range(num_images):\n", + " for t in range(num_tiles):\n", + " # Extract the 2 hits for tile t of image i\n", + " tile_hits = normalized_centers[i, t] # shape (2,2)\n", + " # Determine how many are nonzero\n", + " row_nonzero = np.any(tile_hits != 0, axis=-1) # shape (2,)\n", + " hits_count = np.sum(row_nonzero) # 0,1, or 2\n", + " num_hits_distribution[hits_count] += 1\n", + "\n", + "print(\"Distribution of hits across all tiles:\")\n", + "for k in [0,1,2]:\n", + " print(f\"{k} hits: {num_hits_distribution[k]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 93\n", + "False Positives (FP): 15\n", + "False Negatives (FN): 4\n", + "Precision: 0.8611, Recall: 0.9588\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "\n", + "threshold = 0.8 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits): \n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1* tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 99\n", + "False Positives (FP): 0\n", + "False Negatives (FN): 0\n", + "Precision: 1.0000, Recall: 1.0000\n" + ] + } + ], + "source": [ + "\n", + "\n", + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.8\n", + "tile_size = 8\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " matched_true_hits = set()\n", + " matched_predictions = set()\n", + "\n", + " for pred_idx, pred in enumerate(valid_predicted_hits):\n", + " if pred_idx in matched_predictions:\n", + " continue\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1 *tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " matched_predictions.add(pred_idx)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage\n", + "tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# Plotting\n", + "fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "for i in range(4):\n", + " ax[i].imshow(tiles[i], cmap='gray')\n", + " ax[i].set_title(f\"Tile {i}\")\n", + " ax[i].axis('off')\n", + "\n", + "ax[4].imshow(reconstructed_image, cmap='gray')\n", + "ax[4].set_title(\"Reconstructed Image\")\n", + "ax[4].axis('off')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.2):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "c = np.random.randint(0,50)\n", + "image_index = c # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sinkhorn Loss: tf.Tensor(-4.9335227, shape=(), dtype=float32)\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + " \n", + "def sinkhorn_normalization(cost_matrix, num_iters=50, epsilon=1e-6):\n", + " \"\"\"Performs Sinkhorn normalization to approximate the doubly stochastic matrix.\"\"\"\n", + " for _ in range(num_iters):\n", + " cost_matrix -= tf.reduce_logsumexp(cost_matrix, axis=1, keepdims=True)\n", + " cost_matrix -= tf.reduce_logsumexp(cost_matrix, axis=0, keepdims=True)\n", + " return tf.exp(cost_matrix)\n", + " \n", + "def sinkhorn_loss(y_true, y_pred):\n", + " cost_matrix = tf.norm(tf.expand_dims(y_true, 1) - tf.expand_dims(y_pred, 0), axis=2)\n", + " log_doubly_stochastic = sinkhorn_normalization(-cost_matrix)\n", + " loss = -tf.reduce_sum(log_doubly_stochastic * cost_matrix)\n", + " return loss\n", + " \n", + "# Example usage\n", + "y_true = tf.random.uniform((10, 2))\n", + "y_pred = tf.random.uniform((10, 2))\n", + "loss = sinkhorn_loss(y_true, y_pred)\n", + "print(\"Sinkhorn Loss:\", loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "y_true= [1.2, 3.4], [2.3, 4.5], [0, 0]\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/256 by 256 Training.ipynb b/Computer Vision_Object Detection/256 by 256 Training.ipynb new file mode 100644 index 0000000..81cc4cd --- /dev/null +++ b/Computer Vision_Object Detection/256 by 256 Training.ipynb @@ -0,0 +1,5149 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 13:46:11.276402: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-13 13:46:11.289275: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-13 13:46:11.302076: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-13 13:46:11.305877: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-13 13:46:11.316692: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-13 13:46:11.938786: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 13:46:13.488393: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79194 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2025-01-13 13:46:13.489859: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79194 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2025-01-13 13:46:13.491254: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79194 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + " val_images_flat = val_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + "\n", + " # Flatten centers to match tiles\n", + " train_centers_flat = train_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + " val_centers_flat = val_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # Create TensorFlow datasets\n", + " batch_size = 1000 \n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/10KFixed_100_256by256_RandomindexNoNoise.h5'\n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " \"\"\"\n", + " Create a model that predicts hit locations for individual tiles.\n", + " \n", + " Parameters:\n", + " - input_shape: shape of the input tile (e.g., (8, 8, 1)).\n", + " - max_hits: maximum number of hits per tile (e.g., 2).\n", + "\n", + " Returns:\n", + " - model: The Keras model.\n", + " \"\"\"\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional and pooling layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + "\n", + " # Final dense layer for predictions\n", + " outputs = layers.Dense(max_hits * 2,activation='linear')(x)\n", + "\n", + " # Reshape output to match the target structure per tile\n", + " outputs = layers.Reshape((max_hits, 2))(outputs)\n", + "\n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((8000, 1024, 8, 8),\n", + " (2000, 1024, 8, 8),\n", + " (8000, 1024, 2, 2),\n", + " (2000, 1024, 2, 2))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "true = np.array([\n", + " [[0, 0], [0.5, 0.4]],\n", + " [[0.5, 0.5], [0.7, 0.9]]\n", + "])\n", + "pred = np.array([\n", + " [[0.6, 0.5], [0.7, 0.5]],\n", + " [[0.9, 0.6], [0.5, 0.5]]\n", + "])\n", + "\n", + "# Create a boolean mask where ground truth != [0,0]\n", + "# That means we exclude all positions where true == [0,0].\n", + "nonzero_mask = ~np.all(true == 0, axis=-1) # shape is (2,2) for this example\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "true_filtered = true[nonzero_mask] # shape: (N, 2) where N is # of nonzero points\n", + "pred_filtered = pred[nonzero_mask] # shape: (N, 2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[0.5, 0.4],\n", + " [0.5, 0.5],\n", + " [0.7, 0.9]]),\n", + " array([[0.7, 0.5],\n", + " [0.9, 0.6],\n", + " [0.5, 0.5]]))" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "true_filtered,pred_filtered" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (excluding zero-gt): 0.07\n" + ] + } + ], + "source": [ + "mse = np.mean((true_filtered - pred_filtered) ** 2)\n", + "print(\"MSE (excluding zero-gt):\", mse)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "def masked_mse_excluding_zeros(y_true, y_pred):\n", + " \"\"\"\n", + " Compute the MSE for (batch, max_hits, 2) predictions, \n", + " but exclude any row where y_true == [0,0].\n", + " \"\"\"\n", + "\n", + " # Boolean mask of shape (batch, max_hits):\n", + " # True where ground-truth != [0,0]\n", + " mask = tf.logical_not(\n", + " tf.reduce_all(tf.equal(y_true, 0.0), axis=-1)\n", + " )\n", + "\n", + " # Apply the mask to both y_true and y_pred:\n", + " # This flattens out all valid rows into 1D for each coordinate dimension\n", + " y_true_masked = tf.boolean_mask(y_true, mask)\n", + " y_pred_masked = tf.boolean_mask(y_pred, mask)\n", + "\n", + " # Compute MSE over the remaining entries\n", + " return tf.reduce_mean(tf.square(y_true_masked - y_pred_masked))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 14:24:43.832704: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + } + ], + "source": [ + "train_outputs = model.predict(train_images[1])\n", + "# val_outputs = model.predict(val_images[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(8000, 1024, 8, 8)" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "ename": "InvalidArgumentError", + "evalue": "cannot compute Sub as input #1(zero-based) was expected to be a float tensor but is a double tensor [Op:Sub] name: ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mInvalidArgumentError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[90], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m tl \u001b[38;5;241m=\u001b[39mloss(train_outputs[\u001b[38;5;241m827\u001b[39m],train_centers[\u001b[38;5;241m1\u001b[39m][\u001b[38;5;241m827\u001b[39m])\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# vl = loss(val_outputs,val_centers[1])\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m tl2 \u001b[38;5;241m=\u001b[39m\u001b[43mmasked_mse_excluding_zeros\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_outputs\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m827\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43mtrain_centers\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m827\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m tl,tl2\n", + "Cell \u001b[0;32mIn[9], line 21\u001b[0m, in \u001b[0;36mmasked_mse_excluding_zeros\u001b[0;34m(y_true, y_pred)\u001b[0m\n\u001b[1;32m 18\u001b[0m y_pred_masked \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mboolean_mask(y_pred, mask)\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# Compute MSE over the remaining entries\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mreduce_mean(tf\u001b[38;5;241m.\u001b[39msquare(\u001b[43my_true_masked\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43my_pred_masked\u001b[49m))\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/util/traceback_utils.py:153\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[0;32m--> 153\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/framework/ops.py:5983\u001b[0m, in \u001b[0;36mraise_from_not_ok_status\u001b[0;34m(e, name)\u001b[0m\n\u001b[1;32m 5981\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mraise_from_not_ok_status\u001b[39m(e, name) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m NoReturn:\n\u001b[1;32m 5982\u001b[0m e\u001b[38;5;241m.\u001b[39mmessage \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m name: \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(name \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m-> 5983\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_status_to_exception(e) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[0;31mInvalidArgumentError\u001b[0m: cannot compute Sub as input #1(zero-based) was expected to be a float tensor but is a double tensor [Op:Sub] name: " + ] + } + ], + "source": [ + "loss=tf.keras.losses.MeanSquaredError()\n", + "tl =loss(train_outputs[827],train_centers[1][827])\n", + "# vl = loss(val_outputs,val_centers[1])\n", + "tl2 =masked_mse_excluding_zeros(train_outputs[827],train_centers[1][827])\n", + "tl,tl2" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((2, 2), (2, 2))" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_outputs[827].shape, train_centers[1][827].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.625, 0. ],\n", + " [0. , 0. ]])" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers[1][827]" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.0016805 , 0.00861906],\n", + " [-0.00298151, 0.00353615]], dtype=float32)" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_outputs[827]" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "ename": "InvalidArgumentError", + "evalue": "cannot compute Sub as input #1(zero-based) was expected to be a float tensor but is a double tensor [Op:Sub] name: ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mInvalidArgumentError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[29], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m loss\u001b[38;5;241m=\u001b[39mtf\u001b[38;5;241m.\u001b[39mkeras\u001b[38;5;241m.\u001b[39mlosses\u001b[38;5;241m.\u001b[39mMeanSquaredError()\n\u001b[0;32m----> 2\u001b[0m tl2 \u001b[38;5;241m=\u001b[39m\u001b[43mmasked_mse_excluding_zeros\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_outputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43mtrain_centers\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# vl = loss(val_outputs,val_centers[1])\u001b[39;00m\n\u001b[1;32m 5\u001b[0m tl2\n", + "Cell \u001b[0;32mIn[9], line 21\u001b[0m, in \u001b[0;36mmasked_mse_excluding_zeros\u001b[0;34m(y_true, y_pred)\u001b[0m\n\u001b[1;32m 18\u001b[0m y_pred_masked \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mboolean_mask(y_pred, mask)\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# Compute MSE over the remaining entries\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mreduce_mean(tf\u001b[38;5;241m.\u001b[39msquare(\u001b[43my_true_masked\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43my_pred_masked\u001b[49m))\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/util/traceback_utils.py:153\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[0;32m--> 153\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/framework/ops.py:5983\u001b[0m, in \u001b[0;36mraise_from_not_ok_status\u001b[0;34m(e, name)\u001b[0m\n\u001b[1;32m 5981\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mraise_from_not_ok_status\u001b[39m(e, name) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m NoReturn:\n\u001b[1;32m 5982\u001b[0m e\u001b[38;5;241m.\u001b[39mmessage \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m name: \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(name \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m-> 5983\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_status_to_exception(e) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[0;31mInvalidArgumentError\u001b[0m: cannot compute Sub as input #1(zero-based) was expected to be a float tensor but is a double tensor [Op:Sub] name: " + ] + } + ], + "source": [ + "loss=tf.keras.losses.MeanSquaredError()\n", + "tl2 =masked_mse_excluding_zeros(train_outputs,train_centers[1])\n", + "# vl = loss(val_outputs,val_centers[1])\n", + "\n", + "tl2" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((1024, 2, 2), (1024, 2, 2))" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_outputs.shape, train_centers[1].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, 827)" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = np.random.randint(0,1024)\n", + "plt.imshow(train_images[1][f].reshape(8,8)),f" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.625, 0. ],\n", + " [0. , 0. ]])" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers[1][f]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_1 (InputLayer)      │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (MaxPooling2D)  │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (Flatten)             │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (Dense)                 │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (Dense)                 │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape_1 (Reshape)             │ (None, 2, 2)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_1 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape_1 (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tensorflow.keras.optimizers import Adam\n", + "\n", + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(optimizer = Adam(learning_rate=1e-3), loss=masked_mse_excluding_zeros)\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 12:02:57.240544: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2025-01-13 12:02:57.260844: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2025-01-13 12:02:57.295719: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1736787777.358128 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.358347 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.360499 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.415931 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.415943 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.416157 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.416582 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.416656 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.416842 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.422656 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.422725 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.422756 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.442210 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.442245 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.442242 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.444565 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.444563 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.444812 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.445300 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.445345 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.445664 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.445819 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.445829 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.446128 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.447932 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.448037 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.448130 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.465980 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.465976 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.466013 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.466617 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.466691 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.466721 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.467279 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.467307 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.467368 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.467760 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.467834 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.468117 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.468236 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.468260 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.468699 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.468772 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.468865 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.469056 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.470986 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.471163 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.471202 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.473142 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.473242 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.473344 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.474986 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.475133 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.475228 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.477131 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.477152 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.477283 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.479194 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.479209 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.479331 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.481586 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.481601 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.481733 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.481888 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.483569 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.483644 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.483672 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.491176 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.491204 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.491209 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.493258 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.493366 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.493467 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.567247 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.567558 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.567781 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.568442 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.568857 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.569084 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.569301 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.569522 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.569745 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.569971 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.570205 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.571029 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.571101 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.571422 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.571511 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.571728 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.572044 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.572697 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.572782 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.572948 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.573107 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.573261 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.573414 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.573558 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.573792 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.574018 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.574493 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.574651 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.574922 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.574999 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.575296 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.575425 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.575642 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.575797 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.575943 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.576198 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.576828 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.576904 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.577109 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.577269 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.577416 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.577675 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.578178 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.578489 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.583075 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.583077 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.583463 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.583466 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.583785 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.583788 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.584133 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.584139 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.584627 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.584631 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.585184 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.585314 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.586309 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.586458 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.587416 2228184 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.587556 2228187 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.777987 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.779188 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.780795 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.781025 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.781247 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.781507 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.781828 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.782054 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.783914 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.784153 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.785936 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.791100 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.791747 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.792025 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.795163 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.795535 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.795854 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.796105 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.797671 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.799434 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.799695 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.805733 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.806013 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.806370 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.806862 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.807929 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.809482 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.809959 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.810362 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.810588 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.810901 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.811319 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.819798 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.820042 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.820700 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.820938 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.821646 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.822325 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.825290 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.825523 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.825966 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.825964 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.826239 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.826554 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.826807 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.827314 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.827411 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.827850 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.828107 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.829653 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.829913 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.830232 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.830633 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.831231 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.834962 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.835987 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.841995 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.842050 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.843644 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.843742 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.845216 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.845314 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.846874 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.846971 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.848555 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.848669 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.848983 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.849157 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.849342 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.849519 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.849708 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.849808 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.851099 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.851107 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.851738 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.851748 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.852570 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.852559 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.854321 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.854331 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.855021 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.855119 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.855771 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.855782 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.857244 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.857256 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.857966 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.857977 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.873024 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.873349 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.873576 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.873841 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.874208 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.874617 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.874846 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.875071 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.875080 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.875165 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.875551 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.875697 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.875966 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.876090 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.876263 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.876474 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.876566 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.877263 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.877474 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.877484 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.877734 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.878030 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.878045 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.878301 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.878686 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.878722 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.878963 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.879254 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.879296 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.879529 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.879825 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.879860 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.880092 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.880518 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.880533 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.880654 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.880908 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.881148 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.881937 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.882395 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.882409 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.882555 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.883062 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.883085 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.883102 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.884453 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.884773 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.885054 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.885359 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.885828 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.888262 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.888268 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.888286 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.888754 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.888767 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.889530 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.889569 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.889629 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.890186 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.890197 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.890867 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.890896 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.890980 2228163 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.891238 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.891367 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.892033 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.892132 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.893624 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.893750 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 14/8192\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:08\u001b[0m 8ms/step - loss: 0.2321 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1736787777.998681 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.999159 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.999546 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.999768 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787777.999991 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.000253 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.000591 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.000818 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.001328 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.001561 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.002099 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.002623 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.002857 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.003095 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.003325 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.003566 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.003859 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.004102 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.004558 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.004991 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.005243 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.006753 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.007012 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.007330 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.007730 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.008302 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.011670 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.012690 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.017723 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.018978 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.019715 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.020192 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.020641 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.020954 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.021176 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.021393 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.021938 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.022371 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.022752 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.023229 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.023536 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.023837 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.024387 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.024692 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.031432 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.031745 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.032031 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.032418 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.032685 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.032963 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.033236 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.033518 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.033804 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.034253 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.034633 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.035754 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.036039 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.036495 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.036906 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.037288 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.037561 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.038230 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787778.039262 2228180 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8189/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0160" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 12:04:11.459262: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2025-01-13 12:04:11.459367: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2025-01-13 12:04:11.459486: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1736787852.325458 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.326264 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.326831 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.330628 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.330664 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.330819 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.331241 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.331251 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.331420 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.331744 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.331799 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.332018 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.332439 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.332504 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.332787 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.333032 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.333080 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.333382 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.333657 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.333697 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.333969 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.334252 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.334313 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.334443 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.335091 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.335244 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.335406 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.335694 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.335826 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.335916 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.336299 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.336422 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.336601 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.336858 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.336968 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.337135 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.337522 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.337742 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.337974 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.338354 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.338355 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.338501 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.338889 2228166 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.338935 2228177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736787852.339069 2228189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m85s\u001b[0m 10ms/step - loss: 0.0160 - val_loss: 0.0106 - learning_rate: 0.0010\n", + "Epoch 2/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 12:04:18.282556: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0105" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 12:05:33.148331: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 10ms/step - loss: 0.0105 - val_loss: 0.0103 - learning_rate: 0.0010\n", + "Epoch 3/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 10ms/step - loss: 0.0103 - val_loss: 0.0103 - learning_rate: 0.0010\n", + "Epoch 4/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 12:06:58.762980: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m79s\u001b[0m 9ms/step - loss: 0.0102 - val_loss: 0.0102 - learning_rate: 0.0010\n", + "Epoch 5/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m78s\u001b[0m 9ms/step - loss: 0.0101 - val_loss: 0.0102 - learning_rate: 0.0010\n", + "Epoch 6/30\n", + "\u001b[1m8190/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0101" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 12:10:48.304618: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m78s\u001b[0m 9ms/step - loss: 0.0101 - val_loss: 0.0102 - learning_rate: 0.0010\n", + "Epoch 7/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m78s\u001b[0m 9ms/step - loss: 0.0100 - val_loss: 0.0102 - learning_rate: 0.0010\n", + "Epoch 8/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m76s\u001b[0m 9ms/step - loss: 0.0100 - val_loss: 0.0103 - learning_rate: 0.0010\n", + "Epoch 9/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m77s\u001b[0m 9ms/step - loss: 0.0100 - val_loss: 0.0103 - learning_rate: 0.0010\n", + "Epoch 10/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 10ms/step - loss: 0.0099 - val_loss: 0.0103 - learning_rate: 0.0010\n", + "Epoch 11/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m79s\u001b[0m 9ms/step - loss: 0.0099 - val_loss: 0.0104 - learning_rate: 0.0010\n", + "Epoch 12/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 12:17:25.329702: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m79s\u001b[0m 9ms/step - loss: 0.0099 - val_loss: 0.0104 - learning_rate: 0.0010\n", + "Epoch 13/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m78s\u001b[0m 9ms/step - loss: 0.0098 - val_loss: 0.0104 - learning_rate: 0.0010\n", + "Epoch 14/30\n", + "\u001b[1m8189/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0098\n", + "Epoch 14: ReduceLROnPlateau reducing learning rate to 0.0009000000427477062.\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m78s\u001b[0m 9ms/step - loss: 0.0098 - val_loss: 0.0105 - learning_rate: 0.0010\n", + "Epoch 15/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 10ms/step - loss: 0.0097 - val_loss: 0.0105 - learning_rate: 9.0000e-04\n", + "Epoch 16/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m79s\u001b[0m 9ms/step - loss: 0.0097 - val_loss: 0.0106 - learning_rate: 9.0000e-04\n", + "Epoch 17/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m84s\u001b[0m 10ms/step - loss: 0.0097 - val_loss: 0.0106 - learning_rate: 9.0000e-04\n", + "Epoch 18/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 10ms/step - loss: 0.0097 - val_loss: 0.0106 - learning_rate: 9.0000e-04\n", + "Epoch 19/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 10ms/step - loss: 0.0096 - val_loss: 0.0106 - learning_rate: 9.0000e-04\n", + "Epoch 20/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 10ms/step - loss: 0.0096 - val_loss: 0.0105 - learning_rate: 9.0000e-04\n", + "Epoch 21/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 10ms/step - loss: 0.0096 - val_loss: 0.0105 - learning_rate: 9.0000e-04\n", + "Epoch 22/30\n", + "\u001b[1m8188/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0096" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 12:32:03.239981: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 10ms/step - loss: 0.0096 - val_loss: 0.0106 - learning_rate: 9.0000e-04\n", + "Epoch 23/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 10ms/step - loss: 0.0096 - val_loss: 0.0106 - learning_rate: 9.0000e-04\n", + "Epoch 24/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0095\n", + "Epoch 24: ReduceLROnPlateau reducing learning rate to 0.0008100000384729356.\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 10ms/step - loss: 0.0095 - val_loss: 0.0106 - learning_rate: 9.0000e-04\n", + "Epoch 25/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 10ms/step - loss: 0.0095 - val_loss: 0.0106 - learning_rate: 8.1000e-04\n", + "Epoch 26/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 10ms/step - loss: 0.0095 - val_loss: 0.0107 - learning_rate: 8.1000e-04\n", + "Epoch 27/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m84s\u001b[0m 10ms/step - loss: 0.0094 - val_loss: 0.0108 - learning_rate: 8.1000e-04\n", + "Epoch 28/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m88s\u001b[0m 11ms/step - loss: 0.0094 - val_loss: 0.0108 - learning_rate: 8.1000e-04\n", + "Epoch 29/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m87s\u001b[0m 10ms/step - loss: 0.0094 - val_loss: 0.0107 - learning_rate: 8.1000e-04\n", + "Epoch 30/30\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m87s\u001b[0m 10ms/step - loss: 0.0094 - val_loss: 0.0108 - learning_rate: 8.1000e-04\n" + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=30,\n", + " batch_size=1000,\n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/10KFixed_100_256by256_RandomindexNoNoise_linear_maskingoutemptytiles.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Electron Counting Tiling approach/Trained weights/200KFixed_100_256by256_first1500_mse and sigmoid_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted_centers shape: (4, 1024, 2, 2)\n", + "grouped_targets shape: (4, 1024, 2, 2)\n", + "mask shape: (4, 1024)\n", + "\n", + "Check image index 0\n", + "Tile 0: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n", + "Tile 4: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 1) Fake data: Suppose we have 4 images in a batch (B=4),\n", + "# each with 8x8x1 as \"input images\"...\n", + "# ------------------------------------------------------------------\n", + "B = 4\n", + "train_images = np.random.rand(B, 8, 8, 1).astype(np.float32) \n", + "\n", + "# and each image has 1024 tiles of size 2x2 (just simulating).\n", + "# We'll also pretend half of them are zero to see the effect.\n", + "train_centers = np.random.rand(B, 1024, 2, 2).astype(np.float32)\n", + "train_centers[0, :100] = 0 # Make first 100 tiles be zero for 1st image\n", + "\n", + "# Convert to tf.data.Dataset (usually you'd have many more images)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_centers))\n", + "train_dataset = train_dataset.batch(B) # all in one batch\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 2) Next, get one batch and do a forward pass with your model\n", + "# For demonstration, we'll skip the model and create dummy outputs\n", + "# ------------------------------------------------------------------\n", + "inputs, targets = next(iter(train_dataset)) # shape: (4, 8, 8, 1) and (4, 1024, 2, 2)\n", + "\n", + "# Suppose your model output shape is (B, 1024*4) or (B, 1024, 2, 2)\n", + "# For demonstration, let's pretend we produce random predictions:\n", + "predicted_outputs = np.random.rand(B, 1024, 2, 2).astype(np.float32)\n", + "\n", + "# Flatten them to mimic \"model.predict(inputs)\" returning a flatten shape:\n", + "predicted_outputs_flat = predicted_outputs.reshape(B, 1024*4) \n", + "\n", + "# If your real model is something like:\n", + "# predicted_outputs_flat = model.predict(inputs)\n", + "# Then you'd do the same sort of reshaping below.\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 3) Reshape predictions and targets so they match: (B, 1024, 2, 2)\n", + "# ------------------------------------------------------------------\n", + "predicted_centers = predicted_outputs_flat.reshape(B, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(B, 1024, 2, 2)\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 4) Create a mask where the ground truth is entirely zero for a tile\n", + "# ------------------------------------------------------------------\n", + "mask = np.all(grouped_targets == 0, axis=(-2, -1)) # shape: (B, 1024)\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 5) Force predicted centers to zero where the ground truth is zero\n", + "# ------------------------------------------------------------------\n", + "predicted_centers[mask] = 0\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 6) Print shapes to confirm\n", + "# ------------------------------------------------------------------\n", + "print(\"predicted_centers shape:\", predicted_centers.shape) # (4, 1024, 2, 2)\n", + "print(\"grouped_targets shape: \", grouped_targets.shape) # (4, 1024, 2, 2)\n", + "print(\"mask shape: \", mask.shape) # (4, 1024)\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 7) Inspect a specific image in the batch\n", + "# ------------------------------------------------------------------\n", + "image_index = 0\n", + "tiles_pred = predicted_centers[image_index]\n", + "tiles_true = grouped_targets[image_index]\n", + "\n", + "print(f\"\\nCheck image index {image_index}\")\n", + "for tile_idx, (pred_tile, true_tile) in enumerate(zip(tiles_pred, tiles_true)):\n", + " # Only print first few tiles to keep it short\n", + " if tile_idx < 5:\n", + " print(f\"Tile {tile_idx}: True={true_tile}, Pred={pred_tile}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m256/256\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "Predicted centers shape: (8, 1024, 2, 2)\n", + "Grouped targets shape: (8, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "# # # Flatten validation images and centers\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "\n", + "# Batch size for n images\n", + "batch_size = 8* 1024 # number of images per batch\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "# Make predictions on dataset\n", + "# inputs, targets = next(iter(val_dataset)) # Extract a batch\n", + "inputs, targets = next(iter(train_dataset)) # Extract a batch\n", + "outputs = model.predict(inputs)\n", + "\n", + "# Reshape predictions and targets back to image structure\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 2)\n", + "\n", + "# Print the shapes\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\") # (batch_size // 1024, 1024, 2, 2)\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\") # (batch_size // 1024, 1024, 2, 2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 0:\n", + "Tile 0: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[0.5086723 0.5998142 ]\n", + " [0.4477557 0.57114255]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 4: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 5: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 6: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 7: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[0.11531043 0.85943604]\n", + " [0.12291953 0.7838036 ]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 11: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 18: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 23: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 24: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 28: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 29: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 30: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 31: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 34: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 35: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 37: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 38: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 44: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 46: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 48: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 49: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 51: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[0.47769973 0.311481 ]\n", + " [0.47535104 0.27387244]], True: [[0.5 0.125]\n", + " [0.5 0.375]]\n", + "Tile 53: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 55: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 59: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 61: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 63: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 64: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 65: Predicted: [[0.1283117 0.5030032 ]\n", + " [0.14955504 0.52314186]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 66: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 67: Predicted: [[0.14913586 0.8451868 ]\n", + " [0.15871088 0.7797885 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 68: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 69: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 71: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[ 0.7421275 -0.00097016]\n", + " [ 0.6936983 0.1312811 ]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 73: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 76: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 77: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[0.8172693 0.44537997]\n", + " [0.76296735 0.4050163 ]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 80: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 85: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 86: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 87: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 88: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 90: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 91: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 92: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 93: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 95: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 96: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 98: Predicted: [[0.85165316 0.8363754 ]\n", + " [0.7643863 0.71000624]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 99: Predicted: [[0.16427155 0.03502765]\n", + " [0.32122275 0.23191743]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 100: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 102: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 103: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[0.6260581 0.11498173]\n", + " [0.6315816 0.1655975 ]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 106: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 108: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 111: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 112: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 113: Predicted: [[0.8425392 0.13826047]\n", + " [0.6833178 0.25511464]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 114: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 118: Predicted: [[0.40760404 0.4547821 ]\n", + " [0.41292736 0.49225944]], True: [[0.375 0.5 ]\n", + " [0.875 0. ]]\n", + "Tile 119: Predicted: [[0.42864257 0.7014116 ]\n", + " [0.36450785 0.7315353 ]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 120: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 122: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 124: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 126: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 127: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 129: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 131: Predicted: [[0.2614755 0.11881852]\n", + " [0.28504968 0.1202908 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 134: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 140: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 141: Predicted: [[ 0.0044874 0.52586895]\n", + " [-0.03523579 0.52729887]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 142: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 143: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 145: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 147: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 149: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[0.27134645 0.6835255 ]\n", + " [0.2743014 0.7269665 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 151: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 155: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[ 0.14924598 0.01035252]\n", + " [ 0.22631633 -0.01855353]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 160: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 161: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 162: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[0.8754419 0.11987901]\n", + " [0.83254695 0.14357455]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 164: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 165: Predicted: [[0.01040208 0.87008727]\n", + " [0.02463177 0.8860945 ]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 166: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 167: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[0.48227906 0.53787595]\n", + " [0.48720777 0.5145328 ]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 169: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 171: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 172: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 174: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[0.5003775 0.13205884]\n", + " [0.49082392 0.12218986]], True: [[0.5 0.125]\n", + " [0. 0. ]]\n", + "Tile 179: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 180: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 182: Predicted: [[0.19443369 0.23725104]\n", + " [0.16936201 0.2794725 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 184: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 186: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 188: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 190: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 192: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 194: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 196: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[0.8979387 0.9863211]\n", + " [1.0043914 0.6789664]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 198: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 199: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 201: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 202: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[0.74847037 0.2184341 ]\n", + " [0.7360238 0.14262216]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 205: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 206: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 207: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 210: Predicted: [[0.7496032 0.10303693]\n", + " [0.72053206 0.13570167]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 211: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 212: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 213: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 214: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 215: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 216: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 217: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 218: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 219: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 220: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 222: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 225: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 226: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 227: Predicted: [[0.37324303 0.7378174 ]\n", + " [0.32915446 0.68869555]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 228: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 230: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 231: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 234: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 236: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 237: Predicted: [[0.7427477 0.6536188 ]\n", + " [0.70435464 0.56247294]], True: [[0.75 0.625]\n", + " [0. 0. ]]\n", + "Tile 238: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 239: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 240: Predicted: [[0.35286248 0.7344464 ]\n", + " [0.43246478 0.71495426]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 241: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 242: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[0.3509599 0.12094407]\n", + " [0.34519434 0.15798269]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 244: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 245: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 246: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 247: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 249: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 253: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 254: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 255: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 257: Predicted: [[0.5156902 0.7652395 ]\n", + " [0.52064407 0.7326821 ]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 258: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 259: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 262: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[0.49230647 0.8562237 ]\n", + " [0.48229533 0.7728693 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 264: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 266: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 267: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 268: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[0.637992 0.00875145]\n", + " [0.537006 0.16102009]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 272: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 273: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 274: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 278: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 279: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 280: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 281: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 283: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 284: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 286: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 287: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 288: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 290: Predicted: [[0.8309418 0.8230123]\n", + " [0.7135884 0.6782721]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 291: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 292: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 293: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 294: Predicted: [[0.2996159 0.7399583 ]\n", + " [0.27168238 0.69812834]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 295: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 296: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 297: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 298: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 299: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 300: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 302: Predicted: [[0.5128839 0.5147142 ]\n", + " [0.5338753 0.49364263]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 303: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 304: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 305: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 307: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 309: Predicted: [[0.00678462 0.6329559 ]\n", + " [0.00497884 0.60108757]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 310: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 311: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 313: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 314: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 315: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 317: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 318: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 320: Predicted: [[0.11871929 0.21494216]\n", + " [0.14854048 0.23678514]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 321: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[0.1576202 0.2465711 ]\n", + " [0.17491108 0.2588857 ]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 325: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 328: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 330: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 333: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 334: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 336: Predicted: [[ 0.01042256 0.4480891 ]\n", + " [-0.04112223 0.43935382]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 337: Predicted: [[0.49836037 0.75753367]\n", + " [0.5583652 0.68497074]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 338: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 339: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 340: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 342: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 344: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 345: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 347: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 349: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 350: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 351: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 353: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 354: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 355: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 356: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 362: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 365: Predicted: [[0.3100459 0.32884055]\n", + " [0.29183996 0.31276503]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 366: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 367: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[0.14029542 0.29621392]\n", + " [0.12075359 0.25653407]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 369: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 370: Predicted: [[0.45436186 0.6353642 ]\n", + " [0.48908803 0.5967271 ]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 371: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 372: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[0.14400217 0.07335043]\n", + " [0.14296417 0.15161477]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 374: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 375: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 378: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 380: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 381: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 382: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 383: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 384: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 385: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 386: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 388: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 389: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 393: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 395: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 396: Predicted: [[0.6324479 0.04691634]\n", + " [0.55567926 0.17276043]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 397: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 398: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 399: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 405: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 407: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 408: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 411: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 412: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[0.7103256 0.72488344]\n", + " [0.64297694 0.75271463]], True: [[0.75 0.75]\n", + " [0. 0. ]]\n", + "Tile 414: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 416: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 419: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[0.62820077 0.86560786]\n", + " [0.5405642 0.7811286 ]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 423: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 424: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 425: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 429: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 437: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 441: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 443: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[0.3485131 0.33676207]\n", + " [0.33560023 0.31250542]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 449: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 451: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 453: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 454: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[0.42382163 0.1808674 ]\n", + " [0.42459816 0.16089258]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 457: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 458: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 459: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 460: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 462: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 466: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 467: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 468: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 469: Predicted: [[0.2382124 0.779688 ]\n", + " [0.2578609 0.7228129]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 470: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 471: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 472: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 478: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[0.6634124 0.7580183 ]\n", + " [0.6013843 0.66798043]], True: [[0.75 0.75]\n", + " [0. 0. ]]\n", + "Tile 481: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 482: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 483: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 486: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 487: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 490: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 492: Predicted: [[0.24605148 0.68068993]\n", + " [0.26949072 0.64879054]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 493: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[0.6075113 0.14258413]\n", + " [0.4309284 0.31630686]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 495: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 496: Predicted: [[0.38265592 0.64621913]\n", + " [0.42626607 0.56971467]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 497: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 499: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 500: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 505: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 507: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 509: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 512: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 513: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 517: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 519: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 522: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 523: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 524: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 526: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 529: Predicted: [[0.6422523 0.7664156 ]\n", + " [0.59900856 0.6846999 ]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 530: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 535: Predicted: [[0.38158455 0.11942971]\n", + " [0.3696971 0.15115017]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 536: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 538: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 542: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 543: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 544: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 548: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 549: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 552: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[0.8303044 0.8298563]\n", + " [0.7142611 0.6741681]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 554: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[0.48199296 0.87563443]\n", + " [0.5271681 0.8055235 ]], True: [[0.5 0.875]\n", + " [0. 0. ]]\n", + "Tile 556: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[0.3825781 0.09336449]\n", + " [0.37564564 0.11992492]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 558: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 560: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 561: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 562: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 563: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 565: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 566: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 567: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 568: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 569: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 570: Predicted: [[0.04539342 0.05734277]\n", + " [0.21942271 0.15012676]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 571: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 572: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 579: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 582: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 583: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 584: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 585: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[0.5051438 0.04198557]\n", + " [0.3612145 0.24475664]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 590: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 592: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 594: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 596: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 597: Predicted: [[0.8653408 0.14413027]\n", + " [0.71612614 0.2510162 ]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 598: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 600: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 602: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 603: Predicted: [[0.75224125 0.8219976 ]\n", + " [0.6682769 0.79371697]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 604: Predicted: [[0.21848151 0.1901168 ]\n", + " [0.18980475 0.15737191]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 605: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 606: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 608: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 609: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 610: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[0.01879573 0.20018983]\n", + " [0.09384698 0.25452173]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 613: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[0.32450247 0.59719265]\n", + " [0.3161406 0.60824203]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 617: Predicted: [[0.66527355 0.21898417]\n", + " [0.6618248 0.19859606]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 618: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 619: Predicted: [[0.46833128 0.6675267 ]\n", + " [0.4694094 0.60168403]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 620: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 622: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 623: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[0.5677551 0.8318245 ]\n", + " [0.60246074 0.7299087 ]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 625: Predicted: [[0.7667595 0.2775409 ]\n", + " [0.7387177 0.25016287]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 626: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 627: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 628: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 633: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 634: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 635: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 641: Predicted: [[0.45177794 0.92075574]\n", + " [0.49664634 0.84507674]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 642: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 643: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 645: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 647: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 648: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 649: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 650: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 651: Predicted: [[0.27330583 0.07381244]\n", + " [0.27001402 0.14355631]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 652: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 653: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 654: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 657: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[0.7391817 0.26547107]\n", + " [0.7379463 0.24241093]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 659: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 660: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 662: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 663: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 667: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[0.8965427 0.00560045]\n", + " [0.8379563 0.17582189]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[0.7447429 0.12461488]\n", + " [0.7174524 0.10948011]], True: [[0.875 0.125]\n", + " [0.875 0. ]]\n", + "Tile 674: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 676: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 677: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 679: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 688: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[0.13184635 0.9120152 ]\n", + " [0.11866637 0.71257305]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 693: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 694: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 695: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 698: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 699: Predicted: [[0.00810428 0.13654183]\n", + " [0.10015273 0.13005334]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 700: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 701: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 705: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 706: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 708: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 710: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 711: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 712: Predicted: [[0.16458218 0.30626398]\n", + " [0.15651244 0.31940633]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 713: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 715: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 716: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 717: Predicted: [[0.8416436 0.02422145]\n", + " [0.5159441 0.30647516]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 718: Predicted: [[0.07725903 0.08599041]\n", + " [0.4337124 0.41737372]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 722: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 723: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 724: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 726: Predicted: [[0.64469147 0.25488618]\n", + " [0.61706614 0.277809 ]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 727: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 729: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 730: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 731: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 733: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 734: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 735: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 741: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 742: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 746: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[0.26673493 0.2323918 ]\n", + " [0.25331348 0.19351122]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 748: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 749: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 750: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 751: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 753: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 754: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 756: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 760: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 764: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 765: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 766: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 768: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 771: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 777: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 778: Predicted: [[0.12508275 0.8361388 ]\n", + " [0.10380581 0.74074674]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 779: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 780: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 781: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 786: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 788: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 789: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 790: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 792: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 793: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 795: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 796: Predicted: [[0.47324896 0.45454472]\n", + " [0.47747695 0.45457417]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 797: Predicted: [[0.40001735 0.4536729 ]\n", + " [0.38703552 0.463475 ]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 798: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 799: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 801: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 802: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 805: Predicted: [[0.83123636 0.6220432 ]\n", + " [0.7544446 0.5692011 ]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 806: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 807: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 808: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 809: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 819: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 820: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[0.78275275 0.84615505]\n", + " [0.6148422 0.74466705]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 823: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 824: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 825: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 829: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 830: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 832: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 836: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 838: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 839: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 840: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 841: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 843: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 844: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[0.8232806 0.20360836]\n", + " [0.63841355 0.30473855]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 847: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 850: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 853: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 854: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 857: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 858: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 860: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 861: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 866: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 868: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 874: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 875: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 876: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 878: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 879: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 880: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 883: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[0.8560364 0.14187862]\n", + " [0.8035743 0.18705583]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 885: Predicted: [[0.02066156 0.2704219 ]\n", + " [0.12378582 0.38919502]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 886: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 887: Predicted: [[ 0.11776304 0.01380718]\n", + " [ 0.20445248 -0.00093484]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 888: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 889: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 894: Predicted: [[0.7251574 0.84093624]\n", + " [0.6474748 0.83271146]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 895: Predicted: [[0.39827093 0.12874234]\n", + " [0.37218443 0.1626136 ]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 896: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 901: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 904: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 909: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 912: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 917: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 918: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 919: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 920: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 921: Predicted: [[0.1392031 0.87262124]\n", + " [0.19969375 0.7109982 ]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 922: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 923: Predicted: [[0.3846943 0.30018806]\n", + " [0.37831634 0.30174264]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 924: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 928: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 930: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 935: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[0.48100445 0.06987745]\n", + " [0.49937192 0.01264995]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 937: Predicted: [[0.5082411 0.24954095]\n", + " [0.49994493 0.2273229 ]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 938: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 941: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 942: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 944: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 948: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 949: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 951: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 953: Predicted: [[0.20483464 0.56066823]\n", + " [0.20207804 0.5486798 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 954: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 956: Predicted: [[0.68690145 0.06816798]\n", + " [0.607032 0.11627564]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 957: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 959: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 962: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 964: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 965: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 966: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 967: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[0.42314994 0.35693374]\n", + " [0.4124576 0.34576154]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 969: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 970: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 974: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 976: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 978: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 979: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 980: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 982: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 984: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[0.23563936 0.01439214]\n", + " [0.34458268 0.03604947]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 987: Predicted: [[0.5968591 0.66455865]\n", + " [0.5919528 0.7171679 ]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 988: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 992: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 995: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 996: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[0.63274145 0.46442828]\n", + " [0.6391305 0.4491986 ]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 1001: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1002: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1004: Predicted: [[0.7565594 0.50672066]\n", + " [0.74024314 0.45553982]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 1005: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1006: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[0.63970524 0.01172447]\n", + " [0.5632375 0.14153935]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 1008: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1009: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1012: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1014: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1015: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1016: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1017: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1019: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1020: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1021: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1022: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1023: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "# image_index = np.random.randint(0, 120) # Randomly pick an image in the batch\n", + "image_index = 0\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 99\n", + "False Positives (FP): 1949\n", + "False Negatives (FN): 0\n", + "Precision: 0.0483, Recall: 1.0000\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "\n", + "threshold = 0.1 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits): \n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1* tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 97\n", + "False Positives (FP): 1951\n", + "False Negatives (FN): 2\n", + "Precision: 0.0474, Recall: 0.9798\n" + ] + } + ], + "source": [ + "\n", + "\n", + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.1\n", + "tile_size = 8\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " matched_true_hits = set()\n", + " matched_predictions = set()\n", + "\n", + " for pred_idx, pred in enumerate(valid_predicted_hits):\n", + " if pred_idx in matched_predictions:\n", + " continue\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 0.5 *tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " matched_predictions.add(pred_idx)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage\n", + "tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# Plotting\n", + "fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "for i in range(4):\n", + " ax[i].imshow(tiles[i], cmap='gray')\n", + " ax[i].set_title(f\"Tile {i}\")\n", + " ax[i].axis('off')\n", + "\n", + "ax[4].imshow(reconstructed_image, cmap='gray')\n", + "ax[4].set_title(\"Reconstructed Image\")\n", + "ax[4].axis('off')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.1):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "c = np.random.randint(0,120)\n", + "image_index = 0 # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First image's first tile:\n", + "tf.Tensor(\n", + "[[0. ]\n", + " [0. ]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0. ]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0.00392157]], shape=(8, 1), dtype=float64)\n", + "First image's second tile:\n", + "tf.Tensor(\n", + "[[0. ]\n", + " [0. ]\n", + " [0.00784314]\n", + " [0.00392157]\n", + " [0.00784314]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0.00392157]], shape=(8, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "for val_images, val_centers in val_dataset.take(1):\n", + " print(\"First image's first tile:\")\n", + " print(val_images[2, 0]) # Tile 0 of Image 0\n", + " print(\"First image's second tile:\")\n", + " print(val_images[2, 1]) # Tile 1 of Image 0\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/Adapting YoloFrameGrabber.ipynb b/Computer Vision_Object Detection/Adapting YoloFrameGrabber.ipynb new file mode 100644 index 0000000..2b8c643 --- /dev/null +++ b/Computer Vision_Object Detection/Adapting YoloFrameGrabber.ipynb @@ -0,0 +1,5179 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-27 13:44:43.911877: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-27 13:44:43.925721: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-27 13:44:43.938759: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-27 13:44:43.942686: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-27 13:44:43.953965: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-27 13:44:44.592522: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:1',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-27 13:44:45.775914: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:1\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "# ----------------------\n", + "# 1. Data Loader\n", + "# ----------------------\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:1000])\n", + " centers = np.array(f['centers_training'][:1000])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " \"\"\"\n", + " Returns: \n", + " - tiled_images of shape (num_images, num_tiles, tile_size, tile_size)\n", + " - tiled_centers of shape (num_images, num_tiles, max_hits, 2)\n", + " \"\"\"\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " # Pad or truncate hits to exactly max_hits_per_tile\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] \n", + " + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " \"\"\"\n", + " Normalizes images to [0, 1], \n", + " Normalizes hit coords to [0, 1] inside each tile,\n", + " BUT now we'll add a presence dimension => (p, x, y).\n", + " \"\"\"\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) # [0,1]\n", + "\n", + " # Create presence + (x,y) for each hit\n", + " presence_coords = []\n", + " for image_hit_list in tiled_centers:\n", + " # image_hit_list shape: (num_tiles, max_hits_per_tile, 2)\n", + " new_image_hit_list = []\n", + " for tile_hits in image_hit_list:\n", + " tile_hit_info = []\n", + " for (x, y) in tile_hits:\n", + " # presence=1 if not (0,0), else 0\n", + " if x == 0 and y == 0:\n", + " p = 0.0\n", + " else:\n", + " p = 1.0\n", + " # Normalize x,y by tile_size\n", + " nx = x / self.tile_size\n", + " ny = y / self.tile_size\n", + " tile_hit_info.append((p, nx, ny))\n", + " new_image_hit_list.append(tile_hit_info)\n", + " presence_coords.append(new_image_hit_list)\n", + "\n", + " return normalized_images, np.array(presence_coords)\n", + "\n", + "# ----------------------\n", + "# 2. Create TensorFlow Datasets\n", + "# ----------------------\n", + "def create_datasets(data_loader, train_size=0.95, batch_size=1024):\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + " # Split into train/val at the *image* level\n", + " train_imgs, val_imgs, train_ctrs, val_ctrs = train_test_split(\n", + " normalized_images, normalized_centers,\n", + " train_size=train_size,\n", + " random_state=42\n", + " )\n", + " # Each image has shape (num_tiles, 8, 8)\n", + " # Each label has shape (num_tiles, max_hits, 3)\n", + "\n", + " # Flatten tiles => each tile is an 8×8 patch\n", + " train_imgs_flat = train_imgs.reshape(-1, 8, 8, 1)\n", + " val_imgs_flat = val_imgs.reshape( -1, 8, 8, 1)\n", + "\n", + " # Flatten labels => each tile has shape (max_hits, 3)\n", + " train_ctrs_flat = train_ctrs.reshape(-1, data_loader.max_hits_per_tile, 3)\n", + " val_ctrs_flat = val_ctrs.reshape( -1, data_loader.max_hits_per_tile, 3)\n", + "\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_imgs_flat, train_ctrs_flat))\n", + " train_dataset = train_dataset.shuffle(buffer_size=20480, reshuffle_each_iteration=True)\n", + " train_dataset = train_dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n", + "\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_imgs_flat, val_ctrs_flat))\n", + " val_dataset = val_dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n", + "\n", + " return train_dataset, val_dataset, train_imgs, val_imgs, train_ctrs, val_ctrs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/10KFixed_100_256by256_RandomindexWithNoise.h5' \n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "train_dataset, val_dataset, train_imgs, val_imgs, train_ctrs, val_ctrs = create_datasets(data_loader, train_size=0.95, batch_size=20480)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1000, 100, 3)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "centers.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution of hits across all tiles:\n", + "0 hits: 9300781\n", + "1 hits: 894617\n", + "2 hits: 44602\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# After you load and normalize the data\n", + "normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# Flatten to tile-level\n", + "num_images = normalized_centers.shape[0] # how many big images\n", + "num_tiles = normalized_centers.shape[1] # tiles per image, e.g. 256*256 / (8*8) = 1024\n", + "max_hits = normalized_centers.shape[2] # 2\n", + "_ = normalized_centers.shape[3] # 2 coords\n", + "\n", + "num_hits_distribution = {0: 0, 1: 0, 2: 0}\n", + "\n", + "for i in range(num_images):\n", + " for t in range(num_tiles):\n", + " # Extract the 2 hits for tile t of image i\n", + " tile_hits = normalized_centers[i, t] # shape (2,2)\n", + " # Determine how many are nonzero\n", + " row_nonzero = np.any(tile_hits != 0, axis=-1) # shape (2,)\n", + " hits_count = np.sum(row_nonzero) # 0,1, or 2\n", + " num_hits_distribution[hits_count] += 1\n", + "\n", + "print(\"Distribution of hits across all tiles:\")\n", + "for k in [0,1,2]:\n", + " print(f\"{k} hits: {num_hits_distribution[k]}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution of hits in the current batch:\n", + "0 hits: 46480 tiles\n", + "1 hits: 4506 tiles\n", + "2 hits: 214 tiles\n" + ] + } + ], + "source": [ + "# Get a single batch from the train_dataset\n", + "for train_batch_images, train_batch_centers in train_dataset.take(1): # Take one batch\n", + " # Initialize a dictionary to count hits\n", + " batch_hits_distribution = {0: 0, 1: 0, 2: 0}\n", + " \n", + " # Iterate through the batch\n", + " for tile_hits in train_batch_centers.numpy(): # Convert to NumPy for easier manipulation\n", + " # Determine how many hits are nonzero in the tile\n", + " row_nonzero = np.any(tile_hits != 0, axis=-1) # (max_hits_per_tile,)\n", + " hits_count = np.sum(row_nonzero) # 0, 1, or 2\n", + " batch_hits_distribution[hits_count] += 1\n", + "\n", + " # Print the distribution of hits in the batch\n", + " print(\"Distribution of hits in the current batch:\")\n", + " for k in [0, 1, 2]:\n", + " print(f\"{k} hits: {batch_hits_distribution[k]} tiles\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train dataset hit counts: {'zero_hits': 26505833, 'one_hit': 2552618, 'two_hits': 125549}\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "def count_hits_in_tiles(dataset):\n", + " \"\"\"\n", + " Counts the number of tiles with 0 hits, 1 hit, and 2 hits in the given dataset.\n", + " Args:\n", + " dataset (tf.data.Dataset): The dataset containing tile labels with shape \n", + " (num_tiles, max_hits_per_tile, 3).\n", + " Returns:\n", + " dict: A dictionary with counts for tiles with 0, 1, and 2 hits.\n", + " \"\"\"\n", + " zero_hits, one_hit, two_hits = 0, 0, 0\n", + "\n", + " for _, labels in dataset: # labels shape: (batch_size, num_tiles, max_hits_per_tile, 3)\n", + " # Extract the presence dimension (p) from labels\n", + " presence = labels.numpy()[:, :, 0] # Shape: (batch_size, num_tiles, max_hits_per_tile)\n", + "\n", + " # Count the number of hits per tile\n", + " hits_per_tile = np.sum(presence, axis=-1) # Shape: (batch_size, num_tiles)\n", + "\n", + " # Count tiles with 0, 1, and 2 hits\n", + " zero_hits += np.sum(hits_per_tile == 0)\n", + " one_hit += np.sum(hits_per_tile == 1)\n", + " two_hits += np.sum(hits_per_tile == 2)\n", + "\n", + " return {\n", + " \"zero_hits\": zero_hits,\n", + " \"one_hit\": one_hit,\n", + " \"two_hits\": two_hits\n", + " }\n", + "\n", + "# Usage\n", + "train_hits_count = count_hits_in_tiles(train_dataset)\n", + "print(\"Train dataset hit counts:\", train_hits_count)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Labels shape: (51200, 2, 3)\n", + "Batch hit counts: {'zero_hits': 46480, 'one_hit': 4506, 'two_hits': 214}\n" + ] + } + ], + "source": [ + "def count_hits_in_batch(batch):\n", + " \"\"\"\n", + " Counts the number of tiles with 0 hits, 1 hit, and 2 hits in a batch.\n", + " Args:\n", + " batch (tuple): A tuple of (images, labels), where labels have shape\n", + " (batch_size, num_tiles, max_hits_per_tile, 3).\n", + " Returns:\n", + " dict: A dictionary with counts for tiles with 0, 1, and 2 hits.\n", + " \"\"\"\n", + " _, labels = batch\n", + "\n", + " # Print the shape of labels for debugging\n", + " print(\"Labels shape:\", labels.shape)\n", + "\n", + " # If labels are 3D, adjust indexing (likely missing one dimension)\n", + " if len(labels.shape) == 3: # Shape: (batch_size, num_tiles, 3)\n", + " presence = labels.numpy()[:, :, 0] # Extract presence column\n", + " elif len(labels.shape) == 4: # Shape: (batch_size, num_tiles, max_hits_per_tile, 3)\n", + " presence = labels.numpy()[:, :, :, 0] # Extract presence dimension\n", + " else:\n", + " raise ValueError(f\"Unexpected label shape: {labels.shape}\")\n", + "\n", + " # Count the number of hits per tile\n", + " hits_per_tile = np.sum(presence, axis=-1) # Adjust axis based on shape\n", + "\n", + " # Count tiles with 0, 1, and 2 hits\n", + " zero_hits = np.sum(hits_per_tile == 0)\n", + " one_hit = np.sum(hits_per_tile == 1)\n", + " two_hits = np.sum(hits_per_tile == 2)\n", + "\n", + " return {\n", + " \"zero_hits\": zero_hits,\n", + " \"one_hit\": one_hit,\n", + " \"two_hits\": two_hits\n", + " }\n", + "\n", + "# Get one batch from the train_dataset\n", + "for batch in train_dataset.take(1): # Take a single batch\n", + " batch_hits_count = count_hits_in_batch(batch)\n", + " print(\"Batch hit counts:\", batch_hits_count)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(28500, 1024, 2, 3)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_ctrs.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def gating(tensor):\n", + " raw_p = tensor[..., 0] # shape (batch, max_hits)\n", + " xy = tensor[..., 1:3] # shape (batch, max_hits, 2)\n", + " p = tf.sigmoid(raw_p) # convert logit -> [0..1]\n", + " \n", + " gate = tf.where(p > 0.7, 1.0, 0.0)\n", + " gate = tf.expand_dims(gate, axis=-1) # (batch, max_hits, 1)\n", + " \n", + " xy_gated = xy * gate\n", + " p = tf.expand_dims(p, axis=-1) # shape (batch, max_hits, 1)\n", + "\n", + " return tf.concat([p, xy_gated], axis=-1) # shape (batch, max_hits, 3)\n", + "\n", + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Example convolutional layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x) # shape => (4,4,128)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + "\n", + " # Final dense -> 3 values per hit: (raw_p, x, y)\n", + " x = layers.Dense(max_hits * 3, activation='linear')(x)\n", + " x = layers.Reshape((max_hits, 3))(x) # shape: (batch, max_hits, 3)\n", + "\n", + " # Apply gating\n", + " outputs = layers.Lambda(gating)(x)\n", + " model = Model(inputs, outputs, name=\"GatedModel\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # ----------------------\n", + "# # 4. Custom Loss\n", + "# # ----------------------\n", + "# @tf.function\n", + "# def gating_loss(y_true, y_pred):\n", + "# \"\"\"\n", + "# y_pred shape: (batch, max_hits, 3) => (p_pred, x_pred, y_pred)\n", + "# y_true shape: (batch, max_hits, 3) => (p_true, x_true, y_true)\n", + "\n", + "# We'll do:\n", + "# 1) BCE on p\n", + "# 2) MSE on (x,y) if p_true=1\n", + "# \"\"\"\n", + "# p_true = y_true[..., 0]\n", + "# xy_true = y_true[..., 1:3]\n", + "\n", + "# p_pred = y_pred[..., 0]\n", + "# xy_pred = y_pred[..., 1:3]\n", + "\n", + "# # 1) BCE for presence\n", + "# loss_p = tf.reduce_mean(tf.keras.losses.binary_crossentropy(p_true, p_pred))\n", + "\n", + "# # 2) MSE for (x,y), only if p_true=1\n", + "# object_mask = tf.cast(p_true > 0.5, tf.float32)\n", + "# mse_xy = tf.reduce_sum(tf.square(xy_true - xy_pred), axis=-1) # shape (batch, max_hits)\n", + "\n", + "# # Weighted average over only the positive hits\n", + "# # sum(... * mask) / sum(mask)\n", + "# numerator = tf.reduce_sum(mse_xy * object_mask, axis=-1)\n", + "# denominator = tf.reduce_sum(object_mask, axis=-1) + 1e-8\n", + "# loss_xy_per_sample = numerator / denominator\n", + "# loss_xy = tf.reduce_mean(loss_xy_per_sample)\n", + "\n", + "# return loss_p + loss_xy\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def gating_loss_with_perm_vectorized(y_true, y_pred):\n", + " \"\"\"\n", + " Vectorized gating loss for a batch of tiles, each with (max_hits=2).\n", + " Performs:\n", + " 1) Binary cross-entropy (BCE) on presence p (averaged across batch).\n", + " 2) MSE on (x,y):\n", + " - If a tile has exactly 2 objects, do \"min-of-two\" permutation matching.\n", + " - If a tile has <2 objects, do a simple mask-based approach for whichever slots are p=1.\n", + " Shapes:\n", + " y_true, y_pred: (B, 2, 3) => (p, x, y).\n", + " Returns:\n", + " A scalar loss.\n", + " \"\"\"\n", + "\n", + " # -----------------\n", + " # 1) Presence Loss\n", + " # -----------------\n", + " # p_true, p_pred => (B,2)\n", + " p_true = y_true[..., 0]\n", + " p_pred = y_pred[..., 0]\n", + "\n", + " # BCE across (B,2), then average => scalar\n", + " bce = tf.keras.losses.binary_crossentropy(p_true, p_pred) # shape (B,2)\n", + " loss_p = tf.reduce_mean(bce) # scalar\n", + "\n", + " # -----------------\n", + " # 2) Coordinate Loss\n", + " # -----------------\n", + " # xy_true, xy_pred => (B,2,2)\n", + " xy_true = y_true[..., 1:3]\n", + " xy_pred = y_pred[..., 1:3]\n", + "\n", + " # For each tile, count how many hits are present (p_true>0.5).\n", + " object_mask = tf.cast(p_true > 0.5, tf.float32) # shape (B,2)\n", + " num_objects = tf.reduce_sum(object_mask, axis=1) # shape (B,)\n", + "\n", + " # We'll split the batch into:\n", + " # groupA = tiles with exactly 2 hits\n", + " # groupB = tiles with fewer than 2 hits (0 or 1)\n", + " batch_indices = tf.range(tf.shape(y_true)[0])\n", + " groupA = tf.boolean_mask(batch_indices, tf.equal(num_objects, 2.0)) # shape (N_A,)\n", + " groupB = tf.boolean_mask(batch_indices, tf.less(num_objects, 2.0)) # shape (N_B,)\n", + "\n", + " # Helper: single-slot MSE for groupB\n", + " def single_slot_mse(xy_t, xy_p, om):\n", + " \"\"\"\n", + " xy_t, xy_p: (N,2,2)\n", + " om: (N,2) => object_mask\n", + " Returns a (N,) vector of MSE per tile (masking only the slots where p_true=1).\n", + " \"\"\"\n", + " sq_diff = tf.reduce_sum(tf.square(xy_t - xy_p), axis=-1) # shape (N,2)\n", + " numerator = tf.reduce_sum(sq_diff * om, axis=1) # (N,)\n", + " denominator = tf.reduce_sum(om, axis=1) + 1e-10 # (N,)\n", + " return numerator / denominator # (N,)\n", + "\n", + " # Helper: two-slot MSE (min-of-two permutations) for groupA\n", + " def two_slot_mse(xy_t, xy_p):\n", + " \"\"\"\n", + " xy_t, xy_p: (N,2,2) => For each tile, we have 2 hits.\n", + " Permutation 1: pred0->true0, pred1->true1\n", + " Permutation 2: pred0->true1, pred1->true0\n", + " Returns shape (N,) of the minimal MSE for each tile.\n", + " \"\"\"\n", + " # ssd => sum of squared differences per tile\n", + " def ssd(a, b):\n", + " # a,b => (N,2), returns (N,) each entry is sum of sq diffs across x,y\n", + " return tf.reduce_sum(tf.square(a - b), axis=-1)\n", + "\n", + " # perm1 => ssd(true0,pred0) + ssd(true1,pred1)\n", + " perm1 = ssd(xy_t[:, 0], xy_p[:, 0]) + ssd(xy_t[:, 1], xy_p[:, 1])\n", + " # perm2 => ssd(true0,pred1) + ssd(true1,pred0)\n", + " perm2 = ssd(xy_t[:, 0], xy_p[:, 1]) + ssd(xy_t[:, 1], xy_p[:, 0])\n", + "\n", + " return tf.minimum(perm1, perm2) # (N,)\n", + "\n", + " # Extract groupA and groupB data for xy, object_mask\n", + " xy_true_A = tf.gather(xy_true, groupA, axis=0) # (N_A,2,2)\n", + " xy_pred_A = tf.gather(xy_pred, groupA, axis=0) # (N_A,2,2)\n", + " xy_true_B = tf.gather(xy_true, groupB, axis=0) # (N_B,2,2)\n", + " xy_pred_B = tf.gather(xy_pred, groupB, axis=0) # (N_B,2,2)\n", + " om_B = tf.gather(object_mask, groupB, axis=0) # (N_B,2)\n", + "\n", + " # Compute MSE for each group\n", + " mseA = two_slot_mse(xy_true_A, xy_pred_A) # (N_A,)\n", + " mseB = single_slot_mse(xy_true_B, xy_pred_B, om_B) # (N_B,)\n", + "\n", + " # Reassemble into a single tensor of shape (B,)\n", + " B = tf.shape(y_true)[0]\n", + " zeros = tf.zeros((B,), dtype=tf.float32)\n", + "\n", + " # Scatter the groupA values back\n", + " indicesA = tf.expand_dims(groupA, axis=1) # shape (N_A,1)\n", + " outA = tf.tensor_scatter_nd_update(zeros, indicesA, mseA)\n", + "\n", + " # Scatter the groupB values\n", + " indicesB = tf.expand_dims(groupB, axis=1) # shape (N_B,1)\n", + " outAB = tf.tensor_scatter_nd_update(outA, indicesB, mseB)\n", + "\n", + " # Now outAB is shape (B,) containing the coordinate error for each tile\n", + " loss_xy = tf.reduce_mean(outAB)\n", + "\n", + " # Sum presence + coordinate loss\n", + " return loss_p + loss_xy\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"GatedModel\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"GatedModel\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 6)              │           774 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape (Reshape)               │ (None, 2, 3)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ lambda (Lambda)                 │ (None, 2, 3)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m) │ \u001b[38;5;34m774\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ lambda (\u001b[38;5;33mLambda\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 84,166 (328.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m84,166\u001b[0m (328.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 84,166 (328.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m84,166\u001b[0m (328.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tensorflow.keras.optimizers import Adam\n", + "\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " model = create_model(input_shape=(8, 8, 1), max_hits=2)\n", + " model.compile(optimizer=Adam(learning_rate = 9e-4), loss = gating_loss_with_perm_vectorized) \n", + " model.summary()\n", + " # 4) Compile with custom gating loss\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-27 13:45:27.617765: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "2025-01-27 13:45:28.737456: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1738003528.809011 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.846704 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.847363 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.853102 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.864477 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.866391 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.869575 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.870825 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.873601 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.887161 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.888345 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.889529 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.891044 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.892498 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.894267 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.896927 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.899135 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.902709 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.907059 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.911150 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.913519 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.916876 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003528.919419 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.001536 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.002124 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.002606 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.005702 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.006482 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.017327 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.017976 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.018443 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.019716 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.020210 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.020685 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.021162 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.022778 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.026169 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.027615 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.028123 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.028656 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.029961 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.030487 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.031104 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.031625 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.032716 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.033479 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.049033 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.049821 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.050423 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.051158 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003529.051930 2935651 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.319749 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.321196 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.322058 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.323368 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.324077 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.325583 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.326305 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.327931 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.329265 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.330322 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.331025 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.331825 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.344912 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.350615 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.351797 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.354001 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.366375 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.369069 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.405530 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.407256 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.407986 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.408785 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.409798 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.412129 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.412875 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.413688 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.414538 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.416456 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.419038 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.419903 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.422409 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.424206 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.425101 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.426122 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.427142 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.429056 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.430367 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.431515 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.433192 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.444634 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.446491 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.457771 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.473800 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.514104 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.519653 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 8/48\u001b[0m \u001b[32m━━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.7388" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1738003530.521106 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.523085 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.524971 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.526854 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.528721 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.530815 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.532956 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.534210 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.537096 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.546123 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003530.547977 2935655 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m46/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 36ms/step - loss: 0.5975" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-27 13:45:32.190354: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "W0000 00:00:1738003532.207598 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.208169 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.208622 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.209533 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.210194 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.210738 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.212382 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.213144 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.214072 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.215610 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.216328 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.217056 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.217954 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.218820 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.219847 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.220832 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.221570 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.223033 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.224853 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.226434 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.227728 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.229148 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.243289 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.244211 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.256096 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.256497 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.256847 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.258509 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.258859 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.264380 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.264816 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.265162 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.265516 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.265861 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.266211 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.266557 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.266976 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.268775 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.269145 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.269494 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.269866 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.270258 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.270634 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.271045 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.271408 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.271825 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.272307 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.278738 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.279212 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.279661 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.280131 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.280744 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.281328 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.296911 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.297497 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.297990 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.298469 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.298938 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.299411 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.299942 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.300422 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.300971 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.301442 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.301929 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.302469 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.308797 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.311382 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.318812 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.319551 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.320248 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.326589 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.327606 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.346243 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.346757 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.347238 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.347770 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.348391 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.348912 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.349392 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.349915 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.350461 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.350924 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.351463 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.352001 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.352563 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.353045 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.353613 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.354233 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.354861 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.355430 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.356195 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.356891 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.357841 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.363685 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.364720 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.368132 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.376036 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.389031 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.391285 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 39ms/step - loss: 0.5900" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1738003532.392112 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.393215 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.394270 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.395316 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.396362 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.397522 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.398705 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.399512 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.400990 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.405577 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.406681 2935647 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.697603 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.698506 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.699266 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.700028 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.700821 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.701528 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.702355 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.703118 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.704123 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.705040 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.706117 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.706971 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.708063 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.708942 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.709956 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.710982 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.716024 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.716910 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.717837 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.718774 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.723416 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.724482 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.728439 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.728994 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.729761 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.733200 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.735220 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.736427 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.737481 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.738714 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.740338 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.743080 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.744385 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.745475 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.747863 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.751632 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.753802 2935646 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 54ms/step - loss: 0.5864 - val_loss: 0.1765 - learning_rate: 9.0000e-04\n", + "Epoch 2/4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-27 13:45:32.989865: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "W0000 00:00:1738003532.994683 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.995221 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.995700 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.996204 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.996674 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.997122 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.997638 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.998120 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.998722 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.999355 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003532.999884 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.000437 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.001078 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.001681 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.002196 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.002809 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.003349 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.003840 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.004365 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.004899 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.005480 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.006624 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.008672 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.009049 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.009549 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.011376 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.012504 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.013222 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.013870 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.014592 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.015517 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.017001 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.017772 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.018445 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.019749 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.021745 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.022939 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738003533.032033 2935645 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 46ms/step - loss: 0.1351 - val_loss: 0.0707 - learning_rate: 9.0000e-04\n", + "Epoch 3/4\n", + "\u001b[1m 1/48\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m7s\u001b[0m 157ms/step - loss: 0.0769" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-27 13:45:35.344575: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 47ms/step - loss: 0.0693 - val_loss: 0.0584 - learning_rate: 9.0000e-04\n", + "Epoch 4/4\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 45ms/step - loss: 0.0568 - val_loss: 0.0466 - learning_rate: 9.0000e-04\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-27 13:45:39.960627: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + } + ], + "source": [ + "history =model.fit(train_dataset, validation_data=val_dataset, epochs=4, callbacks=[lr_scheduler])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" + ] + } + ], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/Gating Loss Weights/10KFixed_100_testingsave.h5')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/Gating Loss Weights/10KFixed_100_256by256_RandomindexWithNoise_GatingLoss1.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.17.0\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "print(tf.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n" + ] + } + ], + "source": [ + "loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/Gating Loss Weights/10KFixed_100_testingsave.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 131/1600\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1s\u001b[0m 776us/step" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-27 13:36:35.572731: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "W0000 00:00:1738002995.640081 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.640501 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.640749 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.640961 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.641176 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.641386 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.641598 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.641819 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.642023 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.642235 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.642456 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.642673 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.642908 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.643141 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.643360 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.643566 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.643791 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.644017 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.644257 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.644488 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.644720 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.649580 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1738002995.649844 2753940 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1600/1600\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 813us/step\n", + "Predicted centers shape: (50, 1024, 2, 3)\n", + "Grouped targets shape: (50, 1024, 2, 3)\n" + ] + } + ], + "source": [ + "# Let's say you have your train_dataset or val_dataset with batch_size = 50*1024 (50 images * 1024 tiles/image)\n", + "# The model now outputs (2,3) per tile: (p, x, y).\n", + "\n", + "train_images_flat = train_imgs.reshape(-1, 8, 8, 1)\n", + "train_centers_flat = train_ctrs.reshape(-1, 2, 3) # if your GT also has (p, x, y), or still (x, y) if you only stored that\n", + "\n", + "batch = 50 * 1024\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch)\n", + "\n", + "# Pull out a single batch (all 50 images, flattened to 50*1024 tiles)\n", + "inputs, targets = next(iter(train_dataset))\n", + "# inputs.shape = (50*1024, 8, 8, 1)\n", + "# targets.shape = (50*1024, 2, 3) if your new GT includes presence\n", + "\n", + "outputs = model.predict(inputs)\n", + "# outputs.shape = (50*1024, 2, 3)\n", + "\n", + "# Reshape back to (num_images=50, 1024 tiles, max_hits=2, 3 channels)\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 3) # (50, 1024, 2, 3)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 3) # if your GT is also (p,x,y)\n", + "\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\")\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 48:\n", + "Tile 0:\n", + " Hit #0 => P=0.009, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 1:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 2:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 3:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 4:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 5:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 6:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 7:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 8:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 9:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 10:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 11:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 12:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 13:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 14:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 15:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 16:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 17:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 18:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 19:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 20:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 21:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 22:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 23:\n", + " Hit #0 => P=0.853, X=0.774, Y=0.664 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.612, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 24:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 25:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 26:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 27:\n", + " Hit #0 => P=0.815, X=0.252, Y=0.899 | True=[1. 0.25 0.875]\n", + " Hit #1 => P=0.009, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 28:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 29:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 30:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 31:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 32:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 33:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 34:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 35:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 36:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 37:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 38:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 39:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 40:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 41:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 42:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 43:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 44:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 45:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 46:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 47:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 48:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 49:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 50:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 51:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 52:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 53:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 54:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 55:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[1. 0.625 0. ]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 56:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 57:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 58:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 59:\n", + " Hit #0 => P=0.440, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.004, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 60:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 61:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 62:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 63:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 64:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 65:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 66:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 67:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 68:\n", + " Hit #0 => P=0.899, X=0.184, Y=0.165 | True=[1. 0.125 0.125]\n", + " Hit #1 => P=0.405, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 69:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 70:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 71:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 72:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 73:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 74:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 75:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 76:\n", + " Hit #0 => P=0.871, X=0.013, Y=0.181 | True=[1. 0. 0.125]\n", + " Hit #1 => P=0.031, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 77:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 78:\n", + " Hit #0 => P=0.595, X=0.000, Y=0.000 | True=[1. 0.75 0.125]\n", + " Hit #1 => P=0.002, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 79:\n", + " Hit #0 => P=0.871, X=0.872, Y=0.373 | True=[1. 0.875 0.375]\n", + " Hit #1 => P=0.018, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 80:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 81:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 82:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 83:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 84:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 85:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 86:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 87:\n", + " Hit #0 => P=0.613, X=0.000, Y=0.000 | True=[1. 0.75 0.875]\n", + " Hit #1 => P=0.020, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 88:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 89:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 90:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 91:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 92:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 93:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 94:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 95:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 96:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 97:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 98:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 99:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 100:\n", + " Hit #0 => P=0.995, X=0.793, Y=0.143 | True=[1. 0.75 0.125]\n", + " Hit #1 => P=0.025, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 101:\n", + " Hit #0 => P=0.004, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 102:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 103:\n", + " Hit #0 => P=0.989, X=0.649, Y=0.481 | True=[1. 0.625 0.5 ]\n", + " Hit #1 => P=0.068, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 104:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 105:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 106:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 107:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 108:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 109:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 110:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 111:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 112:\n", + " Hit #0 => P=0.853, X=0.253, Y=0.888 | True=[1. 0.25 0.875]\n", + " Hit #1 => P=0.010, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 113:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 114:\n", + " Hit #0 => P=0.863, X=-0.001, Y=0.565 | True=[1. 0. 0.625]\n", + " Hit #1 => P=0.106, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 115:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 116:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 117:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 118:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 119:\n", + " Hit #0 => P=0.492, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.003, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 120:\n", + " Hit #0 => P=0.835, X=0.089, Y=0.882 | True=[1. 0.125 0.875]\n", + " Hit #1 => P=0.028, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 121:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 122:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 123:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 124:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 125:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 126:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 127:\n", + " Hit #0 => P=0.714, X=0.105, Y=0.851 | True=[1. 0.125 0.875]\n", + " Hit #1 => P=0.013, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 128:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 129:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 130:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 131:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 132:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 133:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 134:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 135:\n", + " Hit #0 => P=0.017, X=0.000, Y=-0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.002, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 136:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 137:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 138:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 139:\n", + " Hit #0 => P=0.875, X=0.619, Y=0.006 | True=[1. 0.625 0. ]\n", + " Hit #1 => P=0.022, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 140:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 141:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 142:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 143:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 144:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 145:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 146:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 147:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 148:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 149:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 150:\n", + " Hit #0 => P=0.689, X=0.000, Y=0.000 | True=[1. 0.625 0.875]\n", + " Hit #1 => P=0.020, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 151:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 152:\n", + " Hit #0 => P=0.879, X=0.398, Y=0.142 | True=[1. 0.375 0.25 ]\n", + " Hit #1 => P=2.277, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 153:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 154:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 155:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 156:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 157:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 158:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 159:\n", + " Hit #0 => P=0.660, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.004, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 160:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 161:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 162:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 163:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 164:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 165:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 166:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 167:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 168:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 169:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 170:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 171:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 172:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 173:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 174:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 175:\n", + " Hit #0 => P=0.096, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 176:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 177:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 178:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 179:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 180:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 181:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 182:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 183:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 184:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 185:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 186:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 187:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 188:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 189:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 190:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 191:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 192:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 193:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 194:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 195:\n", + " Hit #0 => P=0.998, X=0.199, Y=0.116 | True=[1. 0.25 0.125]\n", + " Hit #1 => P=0.009, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 196:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 197:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 198:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 199:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 200:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 201:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 202:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 203:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 204:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 205:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 206:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 207:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 208:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 209:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 210:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 211:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 212:\n", + " Hit #0 => P=0.993, X=0.092, Y=0.582 | True=[1. 0.125 0.625]\n", + " Hit #1 => P=0.030, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 213:\n", + " Hit #0 => P=0.788, X=0.846, Y=0.869 | True=[1. 0.875 0.875]\n", + " Hit #1 => P=0.015, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 214:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 215:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 216:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 217:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 218:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 219:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 220:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 221:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 222:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 223:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 224:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 225:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 226:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 227:\n", + " Hit #0 => P=0.998, X=0.492, Y=0.121 | True=[1. 0.5 0.25]\n", + " Hit #1 => P=0.010, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 228:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 229:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 230:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 231:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 232:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 233:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 234:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 235:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 236:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 237:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 238:\n", + " Hit #0 => P=0.999, X=0.623, Y=0.272 | True=[1. 0.625 0.25 ]\n", + " Hit #1 => P=0.017, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 239:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 240:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 241:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 242:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 243:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 244:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 245:\n", + " Hit #0 => P=0.003, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 246:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 247:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 248:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 249:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 250:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 251:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 252:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 253:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 254:\n", + " Hit #0 => P=0.999, X=0.223, Y=0.625 | True=[1. 0.25 0.625]\n", + " Hit #1 => P=0.005, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 255:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 256:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 257:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 258:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 259:\n", + " Hit #0 => P=0.641, X=0.000, Y=0.000 | True=[1. 0.875 0.75 ]\n", + " Hit #1 => P=0.012, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 260:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 261:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 262:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 263:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 264:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 265:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 266:\n", + " Hit #0 => P=0.995, X=0.538, Y=0.476 | True=[1. 0.625 0.5 ]\n", + " Hit #1 => P=0.072, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 267:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 268:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 269:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 270:\n", + " Hit #0 => P=0.997, X=0.182, Y=0.623 | True=[1. 0.25 0.625]\n", + " Hit #1 => P=0.015, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 271:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 272:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 273:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 274:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 275:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 276:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 277:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 278:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 279:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 280:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 281:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 282:\n", + " Hit #0 => P=0.999, X=0.569, Y=0.258 | True=[1. 0.625 0.25 ]\n", + " Hit #1 => P=0.009, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 283:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 284:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 285:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 286:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 287:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 288:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 289:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 290:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 291:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 292:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 293:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 294:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 295:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 296:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 297:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 298:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 299:\n", + " Hit #0 => P=0.999, X=0.487, Y=0.363 | True=[1. 0.5 0.375]\n", + " Hit #1 => P=0.015, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 300:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 301:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 302:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 303:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 304:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 305:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 306:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 307:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 308:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 309:\n", + " Hit #0 => P=0.868, X=0.846, Y=0.656 | True=[1. 0.875 0.75 ]\n", + " Hit #1 => P=0.087, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 310:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 311:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 312:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 313:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 314:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 315:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 316:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 317:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 318:\n", + " Hit #0 => P=0.809, X=0.086, Y=0.884 | True=[1. 0.125 0.875]\n", + " Hit #1 => P=0.031, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 319:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 320:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 321:\n", + " Hit #0 => P=0.988, X=0.500, Y=0.294 | True=[1. 0.5 0.25]\n", + " Hit #1 => P=0.170, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 322:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 323:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 324:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 325:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 326:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 327:\n", + " Hit #0 => P=0.890, X=0.869, Y=0.102 | True=[1. 0.875 0.125]\n", + " Hit #1 => P=0.044, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 328:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 329:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 330:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 331:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 332:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 333:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 334:\n", + " Hit #0 => P=0.065, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.005, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 335:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 336:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 337:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 338:\n", + " Hit #0 => P=0.865, X=-0.006, Y=0.818 | True=[1. 0. 0.75]\n", + " Hit #1 => P=0.039, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 339:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 340:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 341:\n", + " Hit #0 => P=0.859, X=0.239, Y=0.881 | True=[1. 0.25 0.75]\n", + " Hit #1 => P=0.048, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 342:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 343:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 344:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 345:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 346:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 347:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 348:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 349:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 350:\n", + " Hit #0 => P=0.571, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.010, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 351:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 352:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 353:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 354:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 355:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 356:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 357:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 358:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 359:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 360:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 361:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 362:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 363:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 364:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 365:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 366:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 367:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 368:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 369:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 370:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 371:\n", + " Hit #0 => P=0.547, X=0.000, Y=0.000 | True=[1. 0. 0.25]\n", + " Hit #1 => P=0.005, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 372:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 373:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 374:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 375:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 376:\n", + " Hit #0 => P=0.405, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.011, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 377:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 378:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 379:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 380:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 381:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 382:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 383:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 384:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 385:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 386:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 387:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 388:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 389:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 390:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 391:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 392:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 393:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 394:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 395:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 396:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 397:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 398:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 399:\n", + " Hit #0 => P=0.860, X=0.007, Y=0.273 | True=[1. 0. 0.25]\n", + " Hit #1 => P=0.058, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 400:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 401:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 402:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 403:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 404:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 405:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 406:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 407:\n", + " Hit #0 => P=0.420, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.001, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 408:\n", + " Hit #0 => P=0.040, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.003, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 409:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 410:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 411:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 412:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 413:\n", + " Hit #0 => P=0.977, X=0.485, Y=0.029 | True=[1. 0.5 0. ]\n", + " Hit #1 => P=0.027, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 414:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 415:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 416:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 417:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 418:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 419:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 420:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 421:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 422:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 423:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 424:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 425:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 426:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 427:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 428:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 429:\n", + " Hit #0 => P=0.994, X=0.111, Y=0.132 | True=[1. 0.125 0.25 ]\n", + " Hit #1 => P=0.013, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 430:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 431:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 432:\n", + " Hit #0 => P=0.995, X=0.209, Y=0.432 | True=[1. 0.125 0.375]\n", + " Hit #1 => P=0.073, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 433:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 434:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 435:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 436:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 437:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 438:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 439:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 440:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 441:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 442:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 443:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 444:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 445:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 446:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 447:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 448:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 449:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 450:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 451:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 452:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 453:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 454:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 455:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 456:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 457:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 458:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 459:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 460:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 461:\n", + " Hit #0 => P=0.992, X=0.494, Y=0.061 | True=[1. 0.5 0. ]\n", + " Hit #1 => P=0.024, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 462:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 463:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 464:\n", + " Hit #0 => P=0.084, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.007, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 465:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 466:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 467:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 468:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 469:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 470:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 471:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 472:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 473:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 474:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 475:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 476:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 477:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 478:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 479:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 480:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 481:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 482:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 483:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 484:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 485:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 486:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 487:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 488:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 489:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 490:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 491:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 492:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 493:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 494:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 495:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 496:\n", + " Hit #0 => P=0.989, X=0.495, Y=0.721 | True=[1. 0.5 0.75]\n", + " Hit #1 => P=0.081, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 497:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 498:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 499:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 500:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 501:\n", + " Hit #0 => P=0.999, X=0.610, Y=0.368 | True=[1. 0.625 0.375]\n", + " Hit #1 => P=0.013, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 502:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 503:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 504:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 505:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 506:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 507:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 508:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 509:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 510:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 511:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 512:\n", + " Hit #0 => P=0.974, X=0.137, Y=0.248 | True=[1. 0.25 0.125]\n", + " Hit #1 => P=0.128, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 513:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 514:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 515:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 516:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 517:\n", + " Hit #0 => P=0.965, X=0.225, Y=0.800 | True=[1. 0.25 0.875]\n", + " Hit #1 => P=0.148, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 518:\n", + " Hit #0 => P=0.792, X=-0.000, Y=0.384 | True=[1. 0. 0.375]\n", + " Hit #1 => P=0.021, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 519:\n", + " Hit #0 => P=0.835, X=0.868, Y=0.754 | True=[1. 0.875 0.75 ]\n", + " Hit #1 => P=0.021, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 520:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 521:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 522:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 523:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 524:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 525:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 526:\n", + " Hit #0 => P=0.991, X=0.355, Y=0.730 | True=[1. 0.375 0.75 ]\n", + " Hit #1 => P=0.033, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 527:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 528:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 529:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 530:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 531:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 532:\n", + " Hit #0 => P=0.843, X=0.266, Y=0.870 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.023, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 533:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 534:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 535:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 536:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 537:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 538:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 539:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 540:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 541:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 542:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 543:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 544:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 545:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 546:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 547:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 548:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 549:\n", + " Hit #0 => P=0.429, X=0.000, Y=0.000 | True=[1. 0.875 0.875]\n", + " Hit #1 => P=0.015, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 550:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 551:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 552:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 553:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 554:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 555:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 556:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 557:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 558:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 559:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 560:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 561:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 562:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 563:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 564:\n", + " Hit #0 => P=0.716, X=0.267, Y=0.030 | True=[1. 0.375 0. ]\n", + " Hit #1 => P=0.013, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 565:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 566:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 567:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 568:\n", + " Hit #0 => P=0.999, X=0.239, Y=0.248 | True=[1. 0.25 0.25]\n", + " Hit #1 => P=0.003, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 569:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 570:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 571:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 572:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 573:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 574:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 575:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 576:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 577:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 578:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 579:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 580:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 581:\n", + " Hit #0 => P=0.681, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.015, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 582:\n", + " Hit #0 => P=0.590, X=0.000, Y=0.000 | True=[1. 0.875 0. ]\n", + " Hit #1 => P=0.893, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 583:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 584:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 585:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 586:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 587:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 588:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 589:\n", + " Hit #0 => P=0.857, X=0.266, Y=0.880 | True=[1. 0.25 0.875]\n", + " Hit #1 => P=0.022, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 590:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 591:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 592:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 593:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 594:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 595:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 596:\n", + " Hit #0 => P=0.775, X=0.393, Y=0.786 | True=[1. 0.5 0.75]\n", + " Hit #1 => P=0.078, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 597:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 598:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 599:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 600:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 601:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 602:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 603:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 604:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 605:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 606:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 607:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 608:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 609:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 610:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 611:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 612:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 613:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 614:\n", + " Hit #0 => P=0.998, X=0.357, Y=0.143 | True=[1. 0.375 0.125]\n", + " Hit #1 => P=0.008, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 615:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 616:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 617:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 618:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 619:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 620:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 621:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 622:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 623:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 624:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 625:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 626:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 627:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 628:\n", + " Hit #0 => P=0.802, X=-0.042, Y=0.586 | True=[1. 0.25 0.625]\n", + " Hit #1 => P=0.943, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 629:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 630:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 631:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 632:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 633:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 634:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 635:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 636:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 637:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 638:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 639:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 640:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 641:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 642:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 643:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 644:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 645:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 646:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 647:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 648:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 649:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 650:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 651:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 652:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 653:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 654:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 655:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 656:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 657:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 658:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 659:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 660:\n", + " Hit #0 => P=0.999, X=0.300, Y=0.329 | True=[1. 0.375 0.375]\n", + " Hit #1 => P=0.050, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 661:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 662:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 663:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 664:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 665:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 666:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 667:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 668:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 669:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 670:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 671:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 672:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 673:\n", + " Hit #0 => P=0.993, X=0.054, Y=0.668 | True=[1. 0.125 0.625]\n", + " Hit #1 => P=0.076, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 674:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 675:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 676:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 677:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 678:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 679:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 680:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 681:\n", + " Hit #0 => P=0.983, X=0.161, Y=0.095 | True=[1. 0.125 0.125]\n", + " Hit #1 => P=0.016, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 682:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 683:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 684:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 685:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 686:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 687:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 688:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 689:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 690:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 691:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 692:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 693:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 694:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 695:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 696:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 697:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 698:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 699:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 700:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 701:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 702:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 703:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 704:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 705:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 706:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 707:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 708:\n", + " Hit #0 => P=0.971, X=0.286, Y=0.555 | True=[1. 0.375 0.75 ]\n", + " Hit #1 => P=2.315, X=0.000, Y=0.000 | True=[8. 3. 1.]\n", + "Tile 709:\n", + " Hit #0 => P=0.853, X=0.729, Y=0.238 | True=[0. 0. 0.]\n", + " Hit #1 => P=1.979, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 710:\n", + " Hit #0 => P=0.490, X=0.000, Y=0.000 | True=[1. 0. 0.125]\n", + " Hit #1 => P=0.201, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 711:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 712:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 713:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 714:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 715:\n", + " Hit #0 => P=0.001, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 716:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 717:\n", + " Hit #0 => P=0.637, X=0.000, Y=0.000 | True=[1. 0. 0.875]\n", + " Hit #1 => P=0.009, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 718:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 719:\n", + " Hit #0 => P=0.950, X=0.837, Y=0.245 | True=[1. 0.875 0.125]\n", + " Hit #1 => P=0.055, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 720:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 721:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 722:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 723:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 724:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 725:\n", + " Hit #0 => P=0.977, X=0.792, Y=0.365 | True=[1. 0.75 0.375]\n", + " Hit #1 => P=0.055, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 726:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 727:\n", + " Hit #0 => P=0.997, X=0.759, Y=0.376 | True=[1. 0.75 0.375]\n", + " Hit #1 => P=0.016, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 728:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 729:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 730:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 731:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 732:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 733:\n", + " Hit #0 => P=0.972, X=0.275, Y=0.728 | True=[1. 0.25 0.625]\n", + " Hit #1 => P=0.854, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 734:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 735:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 736:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 737:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 738:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 739:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 740:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 741:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 742:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 743:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 744:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 745:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 746:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 747:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 748:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 749:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 750:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 751:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 752:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 753:\n", + " Hit #0 => P=0.952, X=0.066, Y=0.191 | True=[1. 0.125 0.125]\n", + " Hit #1 => P=0.039, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 754:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 755:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 756:\n", + " Hit #0 => P=0.992, X=0.621, Y=0.092 | True=[1. 0.625 0.125]\n", + " Hit #1 => P=0.014, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 757:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 758:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 759:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 760:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 761:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 762:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 763:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 764:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 765:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 766:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 767:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 768:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 769:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 770:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 771:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 772:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 773:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 774:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 775:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 776:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 777:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 778:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 779:\n", + " Hit #0 => P=0.991, X=0.249, Y=0.284 | True=[1. 0.25 0.25]\n", + " Hit #1 => P=0.147, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 780:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 781:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 782:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 783:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 784:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 785:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 786:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 787:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 788:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 789:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 790:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 791:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 792:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 793:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 794:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 795:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 796:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 797:\n", + " Hit #0 => P=0.985, X=0.580, Y=0.702 | True=[1. 0.625 0.625]\n", + " Hit #1 => P=0.050, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 798:\n", + " Hit #0 => P=0.975, X=0.679, Y=0.062 | True=[1. 0.75 0. ]\n", + " Hit #1 => P=0.142, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 799:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 800:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 801:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 802:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 803:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 804:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 805:\n", + " Hit #0 => P=0.995, X=0.573, Y=0.452 | True=[1. 0.625 0.625]\n", + " Hit #1 => P=0.061, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 806:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 807:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 808:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 809:\n", + " Hit #0 => P=0.569, X=0.000, Y=0.000 | True=[1. 0.875 0.25 ]\n", + " Hit #1 => P=0.004, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 810:\n", + " Hit #0 => P=0.864, X=0.014, Y=0.204 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.103, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 811:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 812:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 813:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 814:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 815:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 816:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 817:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 818:\n", + " Hit #0 => P=0.995, X=0.348, Y=0.107 | True=[1. 0.375 0.125]\n", + " Hit #1 => P=0.013, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 819:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 820:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 821:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 822:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 823:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 824:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 825:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 826:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 827:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 828:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 829:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 830:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 831:\n", + " Hit #0 => P=0.999, X=0.614, Y=0.364 | True=[1. 0.5 0.375]\n", + " Hit #1 => P=0.012, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 832:\n", + " Hit #0 => P=0.935, X=0.698, Y=0.671 | True=[1. 0.75 0.375]\n", + " Hit #1 => P=3.764, X=0.000, Y=0.000 | True=[8. 6. 7.]\n", + "Tile 833:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 834:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 835:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 836:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 837:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 838:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 839:\n", + " Hit #0 => P=0.976, X=0.304, Y=0.454 | True=[1. 0.125 0.625]\n", + " Hit #1 => P=5.277, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 840:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 841:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 842:\n", + " Hit #0 => P=0.790, X=0.847, Y=0.837 | True=[1. 0.875 0.875]\n", + " Hit #1 => P=0.029, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 843:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 844:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 845:\n", + " Hit #0 => P=0.770, X=0.247, Y=-0.016 | True=[1. 0.25 0. ]\n", + " Hit #1 => P=0.015, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 846:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 847:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 848:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 849:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 850:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 851:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 852:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 853:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 854:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 855:\n", + " Hit #0 => P=0.820, X=0.476, Y=0.875 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.086, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 856:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 857:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 858:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 859:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 860:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 861:\n", + " Hit #0 => P=0.994, X=0.359, Y=0.500 | True=[1. 0.375 0.5 ]\n", + " Hit #1 => P=0.024, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 862:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 863:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 864:\n", + " Hit #0 => P=0.476, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.035, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 865:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 866:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 867:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 868:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 869:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 870:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 871:\n", + " Hit #0 => P=0.818, X=0.662, Y=0.192 | True=[1. 0.875 0.375]\n", + " Hit #1 => P=0.178, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 872:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 873:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 874:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 875:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 876:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 877:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 878:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 879:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 880:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 881:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 882:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 883:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 884:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 885:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 886:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 887:\n", + " Hit #0 => P=0.602, X=0.000, Y=0.000 | True=[1. 0.375 0. ]\n", + " Hit #1 => P=0.009, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 888:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 889:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 890:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 891:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 892:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 893:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 894:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 895:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 896:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 897:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 898:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 899:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 900:\n", + " Hit #0 => P=0.463, X=0.000, Y=0.000 | True=[1. 0.625 0. ]\n", + " Hit #1 => P=0.006, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 901:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 902:\n", + " Hit #0 => P=0.915, X=0.470, Y=0.488 | True=[1. 0.625 0. ]\n", + " Hit #1 => P=3.774, X=0.000, Y=0.000 | True=[8. 3. 7.]\n", + "Tile 903:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 904:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 905:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 906:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 907:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 908:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 909:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 910:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 911:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 912:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 913:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 914:\n", + " Hit #0 => P=0.995, X=0.474, Y=0.262 | True=[1. 0.5 0.25]\n", + " Hit #1 => P=0.023, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 915:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 916:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 917:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 918:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 919:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 920:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 921:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 922:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 923:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 924:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 925:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 926:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 927:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 928:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 929:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 930:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 931:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 932:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 933:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 934:\n", + " Hit #0 => P=0.359, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.005, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 935:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 936:\n", + " Hit #0 => P=0.975, X=0.120, Y=0.772 | True=[1. 0.125 0.75 ]\n", + " Hit #1 => P=0.045, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 937:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 938:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 939:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 940:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 941:\n", + " Hit #0 => P=0.995, X=0.183, Y=0.119 | True=[1. 0.125 0.125]\n", + " Hit #1 => P=0.035, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 942:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 943:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 944:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 945:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 946:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 947:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 948:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 949:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 950:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 951:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 952:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 953:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 954:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 955:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 956:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 957:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 958:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 959:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 960:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 961:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 962:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 963:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 964:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 965:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 966:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 967:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 968:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 969:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 970:\n", + " Hit #0 => P=0.850, X=0.852, Y=0.376 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.018, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 971:\n", + " Hit #0 => P=0.752, X=0.044, Y=0.453 | True=[1. 0. 0.5]\n", + " Hit #1 => P=0.016, X=-0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 972:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 973:\n", + " Hit #0 => P=0.963, X=0.488, Y=0.863 | True=[1. 0.5 0.875]\n", + " Hit #1 => P=0.021, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 974:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 975:\n", + " Hit #0 => P=0.729, X=0.118, Y=0.001 | True=[1. 0.125 0.125]\n", + " Hit #1 => P=0.015, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 976:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 977:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 978:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 979:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 980:\n", + " Hit #0 => P=0.999, X=0.514, Y=0.493 | True=[1. 0.625 0.5 ]\n", + " Hit #1 => P=0.006, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 981:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 982:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 983:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 984:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 985:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 986:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 987:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 988:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 989:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 990:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 991:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 992:\n", + " Hit #0 => P=0.964, X=0.308, Y=0.790 | True=[1. 0.375 0.875]\n", + " Hit #1 => P=0.327, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 993:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 994:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 995:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 996:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 997:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 998:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 999:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1000:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1001:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1002:\n", + " Hit #0 => P=0.999, X=0.483, Y=0.524 | True=[1. 0.5 0.625]\n", + " Hit #1 => P=0.037, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 1003:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1004:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1005:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1006:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1007:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1008:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1009:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1010:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1011:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1012:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1013:\n", + " Hit #0 => P=0.998, X=0.369, Y=0.484 | True=[1. 0.375 0.5 ]\n", + " Hit #1 => P=0.017, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 1014:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1015:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1016:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1017:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1018:\n", + " Hit #0 => P=0.998, X=0.748, Y=0.252 | True=[1. 0.75 0.25]\n", + " Hit #1 => P=0.006, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 1019:\n", + " Hit #0 => P=0.826, X=0.584, Y=0.640 | True=[1. 0.5 0.625]\n", + " Hit #1 => P=0.489, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 1020:\n", + " Hit #0 => P=0.597, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.474, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + "Tile 1021:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1022:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n", + "Tile 1023:\n", + " Hit #0 => P=0.002, X=0.000, Y=0.000 | True=[0. 0. 0.]\n", + " Hit #1 => P=0.000, X=-0.000, Y=-0.000 | True=[0. 0. 0.]\n" + ] + } + ], + "source": [ + "\n", + "# Now let's pick an image index\n", + "image_index = np.random.randint(0, 50)\n", + "predicted_image = predicted_centers[image_index] # shape (1024, 2, 3)\n", + "true_targets_image = grouped_targets[image_index] # shape (1024, 2, 3)\n", + "\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # 'pred' is shape (2,3), meaning \"hit_0: (p,x,y), hit_1: (p,x,y)\"\n", + " # 'true' is shape (2,3) if you stored presence in the GT as well\n", + " # or shape (2,2) if not storing presence.\n", + "\n", + " p0, x0, y0 = pred[0]\n", + " p1, x1, y1 = pred[1]*8\n", + "\n", + " # If you want to threshold:\n", + " # For example, \"hit_0\" is valid only if p0 > 0.5\n", + " # Convert the local tile coords back to your final coordinate system if needed\n", + "\n", + " print(f\"Tile {tile_idx}:\")\n", + " print(f\" Hit #0 => P={p0:.3f}, X={x0:.3f}, Y={y0:.3f} | True={true[0]}\")\n", + " print(f\" Hit #1 => P={p1:.3f}, X={x1:.3f}, Y={y1:.3f} | True={true[1]*8}\")\n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TP=87, FP=14, FN=10\n", + "Precision: 0.8614, Recall: 0.8969\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "\n", + "p_threshold = 0.5\n", + "distance_threshold = 8.0 # e.g., 1 tile_size\n", + "\n", + "tile_size = 8\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " \"\"\"\n", + " pred_hits shape: (2,3) => [ (p0, x0, y0), (p1, x1, y1) ]\n", + " true_hits shape: (2,2) or (2,3) if you also store presence\n", + " - If your ground-truth does NOT store presence, you might interpret (x,y) != (0,0) as a real object\n", + " \"\"\"\n", + "\n", + " # 1) Gather valid *predicted* hits\n", + " valid_predicted_hits = []\n", + " for (p, x, y) in pred_hits:\n", + " if p >= p_threshold:\n", + " # Convert normalized [0..1] coords (x,y) to tile-based coords\n", + " abs_x = x * tile_size\n", + " abs_y = y * tile_size\n", + " valid_predicted_hits.append((abs_x, abs_y))\n", + "\n", + " # 2) Gather valid *true* hits\n", + " # If your GT is (p, x, y), do the same p-threshold or if your GT is just (x,y),\n", + " # then you might interpret (0,0) as \"no object,\" anything else is a real object.\n", + " valid_true_hits = []\n", + " for g in true_hits:\n", + " if len(g) == 2:\n", + " # ground truth stored as (x, y)\n", + " (gx, gy) = g\n", + " if (gx, gy) != (0, 0):\n", + " valid_true_hits.append((gx * tile_size, gy * tile_size))\n", + " else:\n", + " # ground truth might be (p, x, y)\n", + " (gp, gx, gy) = g\n", + " if gp >= p_threshold:\n", + " valid_true_hits.append((gx * tile_size, gy * tile_size))\n", + "\n", + " # 3) Match predictions to ground truth\n", + " matched_true_hits = set()\n", + " for (px, py) in valid_predicted_hits:\n", + " matched = False\n", + " for i, (tx, ty) in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue # already matched\n", + "\n", + " distance = np.sqrt((px - tx)**2 + (py - ty)**2)\n", + " if distance <= distance_threshold:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " matched = True\n", + " break\n", + " if not matched:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "precision = TP / (TP + FP) if (TP + FP) else 0\n", + "recall = TP / (TP + FN) if (TP + FN) else 0\n", + "\n", + "print(f\"TP={TP}, FP={FP}, FN={FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(\n", + " image_tiles, predicted_image, true_targets_image,\n", + " tile_size=8, p_threshold=0.5\n", + "):\n", + " \"\"\"\n", + " - image_tiles: shape (1024, 8, 8) for a single image's tiles\n", + " - predicted_image: shape (1024, 2, 3) => each tile has 2 hits, each = (p, x, y)\n", + " - true_targets_image: shape (1024, 2, 2) or (1024, 2, 3)\n", + " \"\"\"\n", + " # 1) Reconstruct the original image\n", + " num_tiles_per_image = predicted_image.shape[0] # e.g., 1024\n", + " grid_size = int(np.sqrt(num_tiles_per_image)) # e.g., 32\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size),\n", + " tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # 2) Show the image + tile grid lines\n", + " plt.figure(figsize=(20, 20))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Optional: draw grid lines\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='black', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='black', linestyle='--', linewidth=0.5)\n", + "\n", + " # 3) Draw True Hits (Green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for hit in true_hits:\n", + " if len(hit) == 2:\n", + " # (x,y)\n", + " x, y = hit\n", + " if (x, y) != (0,0):\n", + " plt.scatter(col_offset + x*tile_size,\n", + " row_offset + y*tile_size,\n", + " color='green', marker='x', s=10)\n", + " else:\n", + " # (p, x, y)\n", + " p, x, y = hit\n", + " if p > 0.5: # or your own threshold\n", + " plt.scatter(col_offset + x*tile_size,\n", + " row_offset + y*tile_size,\n", + " color='green', marker='x', s=10)\n", + "\n", + " # 4) Draw Predicted Hits (Red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (p, x, y) in predicted_hits:\n", + " if p >= p_threshold:\n", + " plt.scatter(col_offset + x*tile_size,\n", + " row_offset + y*tile_size,\n", + " color='red', marker='o', s=5)\n", + "\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c = np.random.randint(0, 50)\n", + "image_index = c\n", + "\n", + "# Extract this image's tiles:\n", + "# inputs are flattened (batch_size*1024), so we slice out [image_index*1024 : (image_index+1)*1024]\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024]\n", + "# predicted centers for that image\n", + "predicted_image = predicted_centers[image_index] # shape => (1024, 2, 3)\n", + "# true centers for that image\n", + "true_targets_image = grouped_targets[image_index] # shape => (1024, 2, 2) or (2, 3)\n", + "\n", + "visualize_image_with_predictions(\n", + " image_tiles, # all 1024 tiles for the image\n", + " predicted_image, # (1024, 2, 3)\n", + " true_targets_image, # (1024, 2, 2) or (2, 3)\n", + " tile_size=8, # Each tile is 8×8\n", + " p_threshold=0.5 # Only show predicted hits if p >= 0.5\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Analysis for Event tiles in the image" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results by # ground-truth hits:\n", + "GT Hits=0: 932 tiles total\n", + " Correct Tiles : 920\n", + " Accuracy : 98.71%\n", + " Avg Offset (px) : 0.00\n", + "\n", + "GT Hits=1: 85 tiles total\n", + " Correct Tiles : 76\n", + " Accuracy : 89.41%\n", + " Avg Offset (px) : 0.81\n", + "\n", + "GT Hits=2: 7 tiles total\n", + " Correct Tiles : 2\n", + " Accuracy : 28.57%\n", + " Avg Offset (px) : 2.21\n", + "\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "def analyze_predictions(\n", + " predicted_image, # shape (1024, 2, 3): (p, x, y)\n", + " true_targets_image, # shape (1024, 2, 3): (p, x, y)\n", + " tile_size=8,\n", + " p_threshold=0.5\n", + "):\n", + " \"\"\"\n", + " Calculate:\n", + " 1) Average pixel offset for tiles that have 0, 1, or 2 ground-truth hits,\n", + " but only for tiles where the predicted #hits == true #hits.\n", + " 2) Accuracy: fraction of tiles for which predicted #hits == true #hits,\n", + " in each category (0,1,2).\n", + " \"\"\"\n", + "\n", + " # Buckets to store stats\n", + " categories = {0: {\"correct_count\": 0, \"total_count\": 0, \"distances\": []},\n", + " 1: {\"correct_count\": 0, \"total_count\": 0, \"distances\": []},\n", + " 2: {\"correct_count\": 0, \"total_count\": 0, \"distances\": []}}\n", + "\n", + " # Convert ground truth (p, x, y) to “hits”\n", + " # A tile’s slot is \"active\" if p_true >= 0.5\n", + " p_true = true_targets_image[..., 0]\n", + " xy_true = true_targets_image[..., 1:3] # shape (1024, 2, 2)\n", + "\n", + " # Convert predicted (p, x, y) to “hits”\n", + " p_pred = predicted_image[..., 0]\n", + " xy_pred = predicted_image[..., 1:3] # shape (1024, 2, 2)\n", + "\n", + " # Iterate over each tile\n", + " num_tiles = predicted_image.shape[0]\n", + " for tile_idx in range(num_tiles):\n", + " # --- Identify how many hits in ground truth ---\n", + " gt_ps = p_true[tile_idx] # shape (2,)\n", + " gt_coords = xy_true[tile_idx] # shape (2,2)\n", + " # Which slots are >=0.5 presence\n", + " gt_mask = gt_ps >= 0.5\n", + " num_gt_hits = np.sum(gt_mask)\n", + "\n", + " # --- Identify how many hits are predicted ---\n", + " pred_ps = p_pred[tile_idx] # shape (2,)\n", + " pred_coords = xy_pred[tile_idx] # shape (2,2)\n", + " pred_mask = pred_ps >= p_threshold\n", + " num_pred_hits = np.sum(pred_mask)\n", + "\n", + " # Update total_count for the category (0,1,2) that ground-truth belongs to\n", + " if num_gt_hits in categories:\n", + " categories[num_gt_hits][\"total_count\"] += 1\n", + " else:\n", + " # If your max_hits=2, we only track 0,1,2. This else shouldn’t happen.\n", + " pass\n", + "\n", + " # If predicted #hits != ground-truth #hits, skip offset calculation\n", + " # => the tile is \"incorrect\" for that category\n", + " if num_pred_hits != num_gt_hits:\n", + " continue\n", + "\n", + " # If we got the correct #hits, we mark \"correct\"\n", + " categories[num_gt_hits][\"correct_count\"] += 1\n", + "\n", + " # Now compute average offset if we want, for *this tile*.\n", + " # For simplicity, we align slot i -> slot i. If we want permutation logic,\n", + " # we can do that, but let's keep it straightforward.\n", + " # We'll compute distance only for the hits that are actually active (p>=0.5).\n", + " # Example approach: sum of distances / number_of_hits\n", + "\n", + " if num_gt_hits > 0:\n", + " # ground truth hits\n", + " active_gt_coords = gt_coords[gt_mask] # shape (num_gt_hits, 2)\n", + " active_pred_coords = pred_coords[pred_mask] # shape (num_gt_hits, 2)\n", + "\n", + " # Convert to pixel coords by multiplying x,y * tile_size\n", + " active_gt_pixels = active_gt_coords * tile_size\n", + " active_pred_pixels = active_pred_coords * tile_size\n", + "\n", + " # Euclidean distance for each matched slot\n", + " # shape => (num_gt_hits,)\n", + " distances = np.sqrt(np.sum((active_gt_pixels - active_pred_pixels)**2, axis=1))\n", + "\n", + " # Store these distances\n", + " categories[num_gt_hits][\"distances\"].extend(distances.tolist())\n", + "\n", + " # If num_gt_hits=0, there's no distance to compute (no objects). \n", + "\n", + " # -- Summarize results --\n", + " results = {}\n", + " for k in [0, 1, 2]:\n", + " cat = categories[k]\n", + " total = cat[\"total_count\"]\n", + " correct = cat[\"correct_count\"]\n", + " acc = correct / total if total > 0 else 0.0\n", + "\n", + " # For average offset, we'll take mean of cat[\"distances\"]\n", + " # If no distances, set to None or 0\n", + " if len(cat[\"distances\"]) == 0:\n", + " avg_offset = 0.0\n", + " else:\n", + " avg_offset = np.mean(cat[\"distances\"])\n", + "\n", + " results[k] = {\n", + " \"total_tiles\": total,\n", + " \"correct_tiles\": correct,\n", + " \"accuracy_percent\": acc * 100.0,\n", + " \"avg_offset_pixels\": avg_offset\n", + " }\n", + "\n", + " return results\n", + "\n", + "# Example usage after your normal \"inputs => model.predict => predicted_image => etc.\":\n", + "\n", + "# predicted_image: shape (1024, 2, 3)\n", + "# true_targets_image: shape (1024, 2, 3)\n", + "results = analyze_predictions(predicted_image, true_targets_image, tile_size=8, p_threshold=0.5)\n", + "\n", + "print(\"Results by # ground-truth hits:\")\n", + "for k in [0, 1, 2]:\n", + " r = results[k]\n", + " print(f\"GT Hits={k}: {r['total_tiles']} tiles total\")\n", + " print(f\" Correct Tiles : {r['correct_tiles']}\")\n", + " print(f\" Accuracy : {r['accuracy_percent']:.2f}%\")\n", + " print(f\" Avg Offset (px) : {r['avg_offset_pixels']:.2f}\\n\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Analysis for all tiles in the image" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total tiles: 1024\n", + "Correct tiles: 990\n", + "Strict tile-level accuracy: 96.68%\n", + "Avg error (px) among correct: 0.54\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "def analyze_strict_accuracy(\n", + " predicted_image, # shape (N, 2, 3) => (p, x, y)\n", + " true_targets_image, # shape (N, 2, 3) => (p, x, y)\n", + " tile_size=8,\n", + " p_threshold=0.5,\n", + " distance_threshold_px=2.0\n", + "):\n", + " \"\"\"\n", + " Evaluate \"strict tile-level accuracy\" by checking:\n", + " 1) The # of predicted hits == the # of ground-truth hits.\n", + " 2) For each hit, the predicted coordinate is within 'distance_threshold_px' \n", + " of the corresponding ground-truth coordinate.\n", + " (If the tile has 2 hits, we align slot0->slot0, slot1->slot1. \n", + " See notes below on permutation logic.)\n", + "\n", + " Returns:\n", + " - strict_accuracy: fraction of tiles that pass these checks (0..1).\n", + " - total_tiles: N\n", + " - num_correct_tiles\n", + " - average_error_pixels (only among correct tiles with hits).\n", + " \"\"\"\n", + "\n", + " N = predicted_image.shape[0]\n", + "\n", + " # Separate presence & coords\n", + " p_true = true_targets_image[..., 0] # shape (N,2)\n", + " xy_true = true_targets_image[..., 1:3] # shape (N,2,2)\n", + " p_pred = predicted_image[..., 0] # shape (N,2)\n", + " xy_pred = predicted_image[..., 1:3] # shape (N,2,2)\n", + "\n", + " correct_tiles = 0\n", + " all_distances = [] # We'll track the (x,y) error for correct tiles\n", + "\n", + " for i in range(N):\n", + " # Identify GT hits\n", + " gt_ps = p_true[i] # shape (2,)\n", + " gt_coords = xy_true[i] # shape (2,2)\n", + " gt_mask = gt_ps >= 0.5\n", + " num_gt_hits = np.sum(gt_mask)\n", + "\n", + " # Identify predicted hits\n", + " pred_ps = p_pred[i]\n", + " pred_coords = xy_pred[i]\n", + " pred_mask = pred_ps >= p_threshold\n", + " num_pred_hits = np.sum(pred_mask)\n", + "\n", + " # (1) Check if # predicted hits == # GT hits\n", + " if num_pred_hits != num_gt_hits:\n", + " # Not correct => skip\n", + " continue\n", + "\n", + " # If we have 0 hits, this tile is correct if the model also predicted 0 hits\n", + " if num_gt_hits == 0:\n", + " correct_tiles += 1\n", + " continue\n", + "\n", + " # If we have hits (1 or 2), we also check the coordinate distance\n", + " # For simplicity, we do \"slot i -> slot i\" alignment. \n", + " # If you want to handle slot-swapping for 2 hits, see further below.\n", + "\n", + " # Extract active GT coords & predicted coords\n", + " active_gt_coords = gt_coords[gt_mask] # shape (num_gt_hits,2)\n", + " active_pred_coords = pred_coords[pred_mask] # shape (num_gt_hits,2)\n", + "\n", + " # Convert normalized tile coords -> absolute pixel coords\n", + " active_gt_pixels = active_gt_coords * tile_size\n", + " active_pred_pixels = active_pred_coords * tile_size\n", + "\n", + " # Compute Euclidean distances for each matched slot\n", + " distances = np.sqrt(np.sum((active_gt_pixels - active_pred_pixels)**2, axis=1))\n", + "\n", + " # (2) Check each matched slot’s distance <= threshold\n", + " if np.all(distances <= distance_threshold_px):\n", + " correct_tiles += 1\n", + " # We'll track these distances so we can compute an average error\n", + " all_distances.extend(distances.tolist())\n", + "\n", + " # Strict tile-level accuracy\n", + " strict_accuracy = correct_tiles / N if N > 0 else 0.0\n", + "\n", + " # Average error among correct tiles that actually have hits\n", + " if len(all_distances) == 0:\n", + " avg_error_pixels = 0.0\n", + " else:\n", + " avg_error_pixels = np.mean(all_distances)\n", + "\n", + " return {\n", + " \"total_tiles\": N,\n", + " \"num_correct_tiles\": correct_tiles,\n", + " \"strict_accuracy\": strict_accuracy,\n", + " \"avg_error_pixels_among_correct\": avg_error_pixels\n", + " }\n", + "\n", + "# Example usage\n", + "results = analyze_strict_accuracy(\n", + " predicted_image=predicted_image, # shape (N, 2, 3)\n", + " true_targets_image=true_targets_image, \n", + " tile_size=8,\n", + " p_threshold=0.5,\n", + " distance_threshold_px=2.0\n", + ")\n", + "\n", + "print(f\"Total tiles: {results['total_tiles']}\")\n", + "print(f\"Correct tiles: {results['num_correct_tiles']}\")\n", + "print(f\"Strict tile-level accuracy: {results['strict_accuracy']:.2%}\")\n", + "print(f\"Avg error (px) among correct: {results['avg_error_pixels_among_correct']:.2f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "# import hls4ml\n", + "# import numpy as np\n", + "\n", + "# def convert_model_to_hls4ml(model_path, output_dir, clock_period=5, part='xcu250-figd2104-2L-e'):\n", + "# \"\"\"\n", + "# Convert a TensorFlow model to hls4ml format\n", + " \n", + "# Parameters:\n", + "# model_path (str): Path to saved TensorFlow model\n", + "# output_dir (str): Directory to save the converted model\n", + "# clock_period (int): Clock period in nanoseconds\n", + "# part (str): FPGA part number\n", + "# \"\"\"\n", + "# # Load the TensorFlow model\n", + "# model = tf.keras.models.load_model(model_path)\n", + " \n", + "# # Print model summary for verification\n", + "# model.summary()\n", + " \n", + "# # Configure hls4ml model conversion\n", + "# hls_config = hls4ml.utils.config_from_keras_model(model, granularity='name')\n", + " \n", + "# # You can customize the configuration here\n", + "# hls_config['Model']['Precision'] = 'ap_fixed<16,6>'\n", + "# hls_config['Model']['ReuseFactor'] = 1\n", + "# hls_config['Model']['Strategy'] = 'Resource'\n", + " \n", + "# # Convert the model\n", + "# hls_model = hls4ml.converters.convert_from_keras_model(\n", + "# model,\n", + "# hls_config=hls_config,\n", + "# output_dir=output_dir,\n", + "# clock_period=clock_period,\n", + "# part=part\n", + "# )\n", + " \n", + "# # Compile the model\n", + "# hls_model.compile()\n", + " \n", + "# return hls_model\n", + "\n", + "# def verify_conversion(original_model, hls_model, test_data, rtol=1e-2, atol=1e-3):\n", + "# \"\"\"\n", + "# Verify the conversion by comparing outputs of original and converted models\n", + " \n", + "# Parameters:\n", + "# original_model: Original TensorFlow model\n", + "# hls_model: Converted hls4ml model\n", + "# test_data: Input data for verification\n", + "# rtol: Relative tolerance for comparison\n", + "# atol: Absolute tolerance for comparison\n", + "# \"\"\"\n", + "# # Get predictions from both models\n", + "# tf_prediction = original_model.predict(test_data)\n", + "# hls_prediction = hls_model.predict(test_data)\n", + " \n", + "# # Compare the results\n", + "# is_close = np.allclose(tf_prediction, hls_prediction, rtol=rtol, atol=atol)\n", + "# max_diff = np.max(np.abs(tf_prediction - hls_prediction))\n", + " \n", + "# print(f\"Maximum difference between predictions: {max_diff}\")\n", + "# print(f\"Predictions match within tolerance: {is_close}\")\n", + " \n", + "# return is_close, max_diff\n", + "\n", + "# # Example usage\n", + "# if __name__ == \"__main__\":\n", + "# # Example parameters\n", + "# MODEL_PATH = \"/home/da886/ElectronCountingProject/weights for custom loss/customlossmodel_epoch_1600.h5\"\n", + "# OUTPUT_DIR = \"hls4ml_output\"\n", + " \n", + "# # Convert the model\n", + "# hls_model = convert_model_to_hls4ml(\n", + "# MODEL_PATH,\n", + "# OUTPUT_DIR,\n", + "# clock_period=5,\n", + "# part='xcu250-figd2104-2L-e'\n", + "# )\n", + " \n", + "# # Generate example test data\n", + "# # Modify shape according to your model's input requirements\n", + "# test_data = np.random.random((100, *hls_model.config.get_layer_config(0)['Shape']))\n", + " \n", + "# # Load original model for verification\n", + "# original_model = tf.keras.models.load_model(MODEL_PATH)\n", + " \n", + "# # Verify the conversion\n", + "# is_close, max_diff = verify_conversion(original_model, hls_model, test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": " could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.src.models.functional', 'class_name': 'Functional', 'config': {'name': 'GatedModel', 'trainable': True, 'layers': [{'module': 'keras.layers', 'class_name': 'InputLayer', 'config': {'batch_shape': [None, 8, 8, 1], 'dtype': 'float32', 'sparse': False, 'name': 'input_layer'}, 'registered_name': None, 'name': 'input_layer', 'inbound_nodes': []}, {'module': 'keras.layers', 'class_name': 'Conv2D', 'config': {'name': 'conv2d', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None}, 'filters': 128, 'kernel_size': [3, 3], 'strides': [1, 1], 'padding': 'valid', 'data_format': 'channels_last', 'dilation_rate': [1, 1], 'groups': 1, 'activation': 'relu', 'use_bias': True, 'kernel_initializer': {'module': 'keras.initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': None}, 'bias_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'kernel_regularizer': None, 'bias_regularizer': None, 'activity_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}, 'registered_name': None, 'build_config': {'input_shape': [None, 8, 8, 1]}, 'name': 'conv2d', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 8, 8, 1], 'dtype': 'float32', 'keras_history': ['input_layer', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'MaxPooling2D', 'config': {'name': 'max_pooling2d', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'pool_size': [2, 2], 'padding': 'valid', 'strides': [2, 2], 'data_format': 'channels_last'}, 'registered_name': None, 'build_config': {'input_shape': [None, 6, 6, 128]}, 'name': 'max_pooling2d', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 6, 6, 128], 'dtype': 'float32', 'keras_history': ['conv2d', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Conv2D', 'config': {'name': 'conv2d_1', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'filters': 64, 'kernel_size': [3, 3], 'strides': [1, 1], 'padding': 'valid', 'data_format': 'channels_last', 'dilation_rate': [1, 1], 'groups': 1, 'activation': 'relu', 'use_bias': True, 'kernel_initializer': {'module': 'keras.initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': None}, 'bias_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'kernel_regularizer': None, 'bias_regularizer': None, 'activity_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}, 'registered_name': None, 'build_config': {'input_shape': [None, 3, 3, 128]}, 'name': 'conv2d_1', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 3, 3, 128], 'dtype': 'float32', 'keras_history': ['max_pooling2d', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Flatten', 'config': {'name': 'flatten', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'data_format': 'channels_last'}, 'registered_name': None, 'build_config': {'input_shape': [None, 1, 1, 64]}, 'name': 'flatten', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 1, 1, 64], 'dtype': 'float32', 'keras_history': ['conv2d_1', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Dense', 'config': {'name': 'dense', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'units': 128, 'activation': 'relu', 'use_bias': True, 'kernel_initializer': {'module': 'keras.initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': None}, 'bias_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'kernel_regularizer': None, 'bias_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}, 'registered_name': None, 'build_config': {'input_shape': [None, 64]}, 'name': 'dense', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 64], 'dtype': 'float32', 'keras_history': ['flatten', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Dense', 'config': {'name': 'dense_1', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'units': 6, 'activation': 'linear', 'use_bias': True, 'kernel_initializer': {'module': 'keras.initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': None}, 'bias_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'kernel_regularizer': None, 'bias_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}, 'registered_name': None, 'build_config': {'input_shape': [None, 128]}, 'name': 'dense_1', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 128], 'dtype': 'float32', 'keras_history': ['dense', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Reshape', 'config': {'name': 'reshape', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'target_shape': [2, 3]}, 'registered_name': None, 'build_config': {'input_shape': [None, 6]}, 'name': 'reshape', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 6], 'dtype': 'float32', 'keras_history': ['dense_1', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Lambda', 'config': {'name': 'lambda', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'function': {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}, 'arguments': {}}, 'registered_name': None, 'build_config': {'input_shape': [None, 2, 3]}, 'name': 'lambda', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 2, 3], 'dtype': 'float32', 'keras_history': ['reshape', 0, 0]}}], 'kwargs': {'mask': None}}]}], 'input_layers': [['input_layer', 0, 0]], 'output_layers': [['lambda', 0, 0]]}, 'registered_name': 'Functional', 'build_config': {'input_shape': None}, 'compile_config': {'optimizer': {'module': 'keras.optimizers', 'class_name': 'Adam', 'config': {'name': 'adam', 'learning_rate': 0.0008999999845400453, 'weight_decay': None, 'clipnorm': None, 'global_clipnorm': None, 'clipvalue': None, 'use_ema': False, 'ema_momentum': 0.99, 'ema_overwrite_frequency': None, 'loss_scale_factor': None, 'gradient_accumulation_steps': None, 'beta_1': 0.9, 'beta_2': 0.999, 'epsilon': 1e-07, 'amsgrad': False}, 'registered_name': None}, 'loss': {'module': 'tensorflow.python.eager.polymorphic_function.polymorphic_function', 'class_name': 'Function', 'config': 'gating_loss_with_perm_vectorized', 'registered_name': 'Function'}, 'loss_weights': None, 'metrics': None, 'weighted_metrics': None, 'run_eagerly': False, 'steps_per_execution': 1, 'jit_compile': False}}.\n\nException encountered: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.layers', 'class_name': 'Lambda', 'config': {'name': 'lambda', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'function': {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}, 'arguments': {}}, 'registered_name': None, 'build_config': {'input_shape': [None, 2, 3]}, 'name': 'lambda', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 2, 3], 'dtype': 'float32', 'keras_history': ['reshape', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: Could not locate function 'gating'. Make sure custom classes are decorated with `@keras.saving.register_keras_serializable()`. Full object config: {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/serialization_lib.py:718\u001b[0m, in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 717\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 718\u001b[0m instance \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_config\u001b[49m\u001b[43m(\u001b[49m\u001b[43minner_config\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/core/lambda_layer.py:199\u001b[0m, in \u001b[0;36mLambda.from_config\u001b[0;34m(cls, config, custom_objects, safe_mode)\u001b[0m\n\u001b[1;32m 198\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 199\u001b[0m config[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfunction\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mserialization_lib\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdeserialize_keras_object\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 200\u001b[0m \u001b[43m \u001b[49m\u001b[43mfn_config\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcustom_objects\u001b[49m\n\u001b[1;32m 201\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moutput_shape\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m config:\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/serialization_lib.py:678\u001b[0m, in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 677\u001b[0m fn_name \u001b[38;5;241m=\u001b[39m inner_config\n\u001b[0;32m--> 678\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_retrieve_class_or_fn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 679\u001b[0m \u001b[43m \u001b[49m\u001b[43mfn_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 680\u001b[0m \u001b[43m \u001b[49m\u001b[43mregistered_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 681\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodule\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 682\u001b[0m \u001b[43m \u001b[49m\u001b[43mobj_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunction\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 683\u001b[0m \u001b[43m \u001b[49m\u001b[43mfull_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 684\u001b[0m \u001b[43m \u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcustom_objects\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 685\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 687\u001b[0m \u001b[38;5;66;03m# Below, handling of all classes.\u001b[39;00m\n\u001b[1;32m 688\u001b[0m \u001b[38;5;66;03m# First, is it a shared object?\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/serialization_lib.py:812\u001b[0m, in \u001b[0;36m_retrieve_class_or_fn\u001b[0;34m(name, registered_name, module, obj_type, full_config, custom_objects)\u001b[0m\n\u001b[1;32m 810\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m obj\n\u001b[0;32m--> 812\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m 813\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCould not locate \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mobj_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 814\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMake sure custom classes are decorated with \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 815\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`@keras.saving.register_keras_serializable()`. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 816\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFull object config: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfull_config\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 817\u001b[0m )\n", + "\u001b[0;31mTypeError\u001b[0m: Could not locate function 'gating'. Make sure custom classes are decorated with `@keras.saving.register_keras_serializable()`. Full object config: {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/serialization_lib.py:718\u001b[0m, in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 717\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 718\u001b[0m instance \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_config\u001b[49m\u001b[43m(\u001b[49m\u001b[43minner_config\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/models/model.py:521\u001b[0m, in \u001b[0;36mModel.from_config\u001b[0;34m(cls, config, custom_objects)\u001b[0m\n\u001b[1;32m 519\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mkeras\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01msrc\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmodels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfunctional\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m functional_from_config\n\u001b[0;32m--> 521\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunctional_from_config\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 522\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcustom_objects\u001b[49m\n\u001b[1;32m 523\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 525\u001b[0m \u001b[38;5;66;03m# Either the model has a custom __init__, or the config\u001b[39;00m\n\u001b[1;32m 526\u001b[0m \u001b[38;5;66;03m# does not contain all the information necessary to\u001b[39;00m\n\u001b[1;32m 527\u001b[0m \u001b[38;5;66;03m# revive a Functional model. This happens when the user creates\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 530\u001b[0m \u001b[38;5;66;03m# In this case, we fall back to provide all config into the\u001b[39;00m\n\u001b[1;32m 531\u001b[0m \u001b[38;5;66;03m# constructor of the class.\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/models/functional.py:477\u001b[0m, in \u001b[0;36mfunctional_from_config\u001b[0;34m(cls, config, custom_objects)\u001b[0m\n\u001b[1;32m 476\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m layer_data \u001b[38;5;129;01min\u001b[39;00m config[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlayers\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n\u001b[0;32m--> 477\u001b[0m \u001b[43mprocess_layer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlayer_data\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 479\u001b[0m \u001b[38;5;66;03m# Then we process nodes in order of layer depth.\u001b[39;00m\n\u001b[1;32m 480\u001b[0m \u001b[38;5;66;03m# Nodes that cannot yet be processed (if the inbound node\u001b[39;00m\n\u001b[1;32m 481\u001b[0m \u001b[38;5;66;03m# does not yet exist) are re-enqueued, and the process\u001b[39;00m\n\u001b[1;32m 482\u001b[0m \u001b[38;5;66;03m# is repeated until all nodes are processed.\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/models/functional.py:461\u001b[0m, in \u001b[0;36mfunctional_from_config..process_layer\u001b[0;34m(layer_data)\u001b[0m\n\u001b[1;32m 460\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 461\u001b[0m layer \u001b[38;5;241m=\u001b[39m \u001b[43mserialization_lib\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdeserialize_keras_object\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 462\u001b[0m \u001b[43m \u001b[49m\u001b[43mlayer_data\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcustom_objects\u001b[49m\n\u001b[1;32m 463\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 464\u001b[0m created_layers[layer_name] \u001b[38;5;241m=\u001b[39m layer\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/serialization_lib.py:720\u001b[0m, in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m--> 720\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m 721\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m could not be deserialized properly. Please\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 722\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m ensure that components that are Python object\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 723\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m instances (layers, models, etc.) returned by\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 724\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m `get_config()` are explicitly deserialized in the\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 725\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m model\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms `from_config()` method.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 726\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mconfig=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mconfig\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mException encountered: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00me\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 727\u001b[0m )\n\u001b[1;32m 728\u001b[0m build_config \u001b[38;5;241m=\u001b[39m config\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbuild_config\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n", + "\u001b[0;31mTypeError\u001b[0m: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.layers', 'class_name': 'Lambda', 'config': {'name': 'lambda', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'function': {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}, 'arguments': {}}, 'registered_name': None, 'build_config': {'input_shape': [None, 2, 3]}, 'name': 'lambda', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 2, 3], 'dtype': 'float32', 'keras_history': ['reshape', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: Could not locate function 'gating'. Make sure custom classes are decorated with `@keras.saving.register_keras_serializable()`. Full object config: {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[9], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# import hls4ml\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m loaded_model \u001b[38;5;241m=\u001b[39m \u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkeras\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodels\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload_model\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m/home/da886/Computer Vision_Object Detection/Trained_Weights/Gating Loss Weights/10KFixed_100_256by256_RandomindexWithNoise_GatingLoss.keras\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mgating_loss_with_perm_vectorized\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mgating_loss_with_perm_vectorized\u001b[49m\u001b[43m}\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/saving_api.py:182\u001b[0m, in \u001b[0;36mload_model\u001b[0;34m(filepath, custom_objects, compile, safe_mode)\u001b[0m\n\u001b[1;32m 179\u001b[0m is_keras_zip \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 181\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_keras_zip \u001b[38;5;129;01mor\u001b[39;00m is_keras_dir:\n\u001b[0;32m--> 182\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msaving_lib\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 183\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilepath\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 184\u001b[0m \u001b[43m \u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcustom_objects\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 185\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mcompile\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mcompile\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 186\u001b[0m \u001b[43m \u001b[49m\u001b[43msafe_mode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msafe_mode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 187\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mstr\u001b[39m(filepath)\u001b[38;5;241m.\u001b[39mendswith((\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m.h5\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m.hdf5\u001b[39m\u001b[38;5;124m\"\u001b[39m)):\n\u001b[1;32m 189\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m legacy_h5_format\u001b[38;5;241m.\u001b[39mload_model_from_hdf5(\n\u001b[1;32m 190\u001b[0m filepath, custom_objects\u001b[38;5;241m=\u001b[39mcustom_objects, \u001b[38;5;28mcompile\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mcompile\u001b[39m\n\u001b[1;32m 191\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/saving_lib.py:237\u001b[0m, in \u001b[0;36mload_model\u001b[0;34m(filepath, custom_objects, compile, safe_mode)\u001b[0m\n\u001b[1;32m 232\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 233\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid filename: expected a `.keras` extension. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 234\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mReceived: filepath=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfilepath\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 235\u001b[0m )\n\u001b[1;32m 236\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(filepath, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[0;32m--> 237\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_load_model_from_fileobj\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 238\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mcompile\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msafe_mode\u001b[49m\n\u001b[1;32m 239\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/saving_lib.py:314\u001b[0m, in \u001b[0;36m_load_model_from_fileobj\u001b[0;34m(fileobj, custom_objects, compile, safe_mode)\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m zf\u001b[38;5;241m.\u001b[39mopen(_CONFIG_FILENAME, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m 312\u001b[0m config_json \u001b[38;5;241m=\u001b[39m f\u001b[38;5;241m.\u001b[39mread()\n\u001b[0;32m--> 314\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43m_model_from_config\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 315\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig_json\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mcompile\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msafe_mode\u001b[49m\n\u001b[1;32m 316\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 318\u001b[0m all_filenames \u001b[38;5;241m=\u001b[39m zf\u001b[38;5;241m.\u001b[39mnamelist()\n\u001b[1;32m 319\u001b[0m weights_file_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/saving_lib.py:303\u001b[0m, in \u001b[0;36m_model_from_config\u001b[0;34m(config_json, custom_objects, compile, safe_mode)\u001b[0m\n\u001b[1;32m 301\u001b[0m \u001b[38;5;66;03m# Construct the model from the configuration file in the archive.\u001b[39;00m\n\u001b[1;32m 302\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m ObjectSharingScope():\n\u001b[0;32m--> 303\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mdeserialize_keras_object\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[43mconfig_dict\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcustom_objects\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msafe_mode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msafe_mode\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 306\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m model\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/serialization_lib.py:720\u001b[0m, in \u001b[0;36mdeserialize_keras_object\u001b[0;34m(config, custom_objects, safe_mode, **kwargs)\u001b[0m\n\u001b[1;32m 718\u001b[0m instance \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mfrom_config(inner_config)\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m--> 720\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m 721\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m could not be deserialized properly. Please\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 722\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m ensure that components that are Python object\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 723\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m instances (layers, models, etc.) returned by\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 724\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m `get_config()` are explicitly deserialized in the\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 725\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m model\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms `from_config()` method.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 726\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mconfig=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mconfig\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124mException encountered: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00me\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 727\u001b[0m )\n\u001b[1;32m 728\u001b[0m build_config \u001b[38;5;241m=\u001b[39m config\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbuild_config\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 729\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m build_config \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m instance\u001b[38;5;241m.\u001b[39mbuilt:\n", + "\u001b[0;31mTypeError\u001b[0m: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.src.models.functional', 'class_name': 'Functional', 'config': {'name': 'GatedModel', 'trainable': True, 'layers': [{'module': 'keras.layers', 'class_name': 'InputLayer', 'config': {'batch_shape': [None, 8, 8, 1], 'dtype': 'float32', 'sparse': False, 'name': 'input_layer'}, 'registered_name': None, 'name': 'input_layer', 'inbound_nodes': []}, {'module': 'keras.layers', 'class_name': 'Conv2D', 'config': {'name': 'conv2d', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None}, 'filters': 128, 'kernel_size': [3, 3], 'strides': [1, 1], 'padding': 'valid', 'data_format': 'channels_last', 'dilation_rate': [1, 1], 'groups': 1, 'activation': 'relu', 'use_bias': True, 'kernel_initializer': {'module': 'keras.initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': None}, 'bias_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'kernel_regularizer': None, 'bias_regularizer': None, 'activity_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}, 'registered_name': None, 'build_config': {'input_shape': [None, 8, 8, 1]}, 'name': 'conv2d', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 8, 8, 1], 'dtype': 'float32', 'keras_history': ['input_layer', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'MaxPooling2D', 'config': {'name': 'max_pooling2d', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'pool_size': [2, 2], 'padding': 'valid', 'strides': [2, 2], 'data_format': 'channels_last'}, 'registered_name': None, 'build_config': {'input_shape': [None, 6, 6, 128]}, 'name': 'max_pooling2d', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 6, 6, 128], 'dtype': 'float32', 'keras_history': ['conv2d', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Conv2D', 'config': {'name': 'conv2d_1', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'filters': 64, 'kernel_size': [3, 3], 'strides': [1, 1], 'padding': 'valid', 'data_format': 'channels_last', 'dilation_rate': [1, 1], 'groups': 1, 'activation': 'relu', 'use_bias': True, 'kernel_initializer': {'module': 'keras.initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': None}, 'bias_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'kernel_regularizer': None, 'bias_regularizer': None, 'activity_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}, 'registered_name': None, 'build_config': {'input_shape': [None, 3, 3, 128]}, 'name': 'conv2d_1', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 3, 3, 128], 'dtype': 'float32', 'keras_history': ['max_pooling2d', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Flatten', 'config': {'name': 'flatten', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'data_format': 'channels_last'}, 'registered_name': None, 'build_config': {'input_shape': [None, 1, 1, 64]}, 'name': 'flatten', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 1, 1, 64], 'dtype': 'float32', 'keras_history': ['conv2d_1', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Dense', 'config': {'name': 'dense', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'units': 128, 'activation': 'relu', 'use_bias': True, 'kernel_initializer': {'module': 'keras.initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': None}, 'bias_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'kernel_regularizer': None, 'bias_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}, 'registered_name': None, 'build_config': {'input_shape': [None, 64]}, 'name': 'dense', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 64], 'dtype': 'float32', 'keras_history': ['flatten', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Dense', 'config': {'name': 'dense_1', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'units': 6, 'activation': 'linear', 'use_bias': True, 'kernel_initializer': {'module': 'keras.initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': None}, 'bias_initializer': {'module': 'keras.initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': None}, 'kernel_regularizer': None, 'bias_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}, 'registered_name': None, 'build_config': {'input_shape': [None, 128]}, 'name': 'dense_1', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 128], 'dtype': 'float32', 'keras_history': ['dense', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Reshape', 'config': {'name': 'reshape', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'target_shape': [2, 3]}, 'registered_name': None, 'build_config': {'input_shape': [None, 6]}, 'name': 'reshape', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 6], 'dtype': 'float32', 'keras_history': ['dense_1', 0, 0]}}], 'kwargs': {}}]}, {'module': 'keras.layers', 'class_name': 'Lambda', 'config': {'name': 'lambda', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'function': {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}, 'arguments': {}}, 'registered_name': None, 'build_config': {'input_shape': [None, 2, 3]}, 'name': 'lambda', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 2, 3], 'dtype': 'float32', 'keras_history': ['reshape', 0, 0]}}], 'kwargs': {'mask': None}}]}], 'input_layers': [['input_layer', 0, 0]], 'output_layers': [['lambda', 0, 0]]}, 'registered_name': 'Functional', 'build_config': {'input_shape': None}, 'compile_config': {'optimizer': {'module': 'keras.optimizers', 'class_name': 'Adam', 'config': {'name': 'adam', 'learning_rate': 0.0008999999845400453, 'weight_decay': None, 'clipnorm': None, 'global_clipnorm': None, 'clipvalue': None, 'use_ema': False, 'ema_momentum': 0.99, 'ema_overwrite_frequency': None, 'loss_scale_factor': None, 'gradient_accumulation_steps': None, 'beta_1': 0.9, 'beta_2': 0.999, 'epsilon': 1e-07, 'amsgrad': False}, 'registered_name': None}, 'loss': {'module': 'tensorflow.python.eager.polymorphic_function.polymorphic_function', 'class_name': 'Function', 'config': 'gating_loss_with_perm_vectorized', 'registered_name': 'Function'}, 'loss_weights': None, 'metrics': None, 'weighted_metrics': None, 'run_eagerly': False, 'steps_per_execution': 1, 'jit_compile': False}}.\n\nException encountered: could not be deserialized properly. Please ensure that components that are Python object instances (layers, models, etc.) returned by `get_config()` are explicitly deserialized in the model's `from_config()` method.\n\nconfig={'module': 'keras.layers', 'class_name': 'Lambda', 'config': {'name': 'lambda', 'trainable': True, 'dtype': {'module': 'keras', 'class_name': 'DTypePolicy', 'config': {'name': 'float32'}, 'registered_name': None, 'shared_object_id': 139942658669792}, 'function': {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}, 'arguments': {}}, 'registered_name': None, 'build_config': {'input_shape': [None, 2, 3]}, 'name': 'lambda', 'inbound_nodes': [{'args': [{'class_name': '__keras_tensor__', 'config': {'shape': [None, 2, 3], 'dtype': 'float32', 'keras_history': ['reshape', 0, 0]}}], 'kwargs': {'mask': None}}]}.\n\nException encountered: Could not locate function 'gating'. Make sure custom classes are decorated with `@keras.saving.register_keras_serializable()`. Full object config: {'module': 'builtins', 'class_name': 'function', 'config': 'gating', 'registered_name': 'function'}" + ] + } + ], + "source": [ + "# import hls4ml\n", + "loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/Gating Loss Weights/10KFixed_100_256by256_RandomindexWithNoise_GatingLoss.keras',custom_objects={'gating_loss_with_perm_vectorized': gating_loss_with_perm_vectorized}\n", + ")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Configure the HLS project\n", + "config = hls4ml.utils.config_from_keras_model(model, default_precision='ap_fixed<16,6>')\n", + "print(config) # Optional: Inspect the generated configuration\n", + "\n", + "# Initialize HLS4ML project\n", + "hls_model = hls4ml.converters.convert_from_keras_model(\n", + " model,\n", + " hls_config=config,\n", + " output_dir='hls4ml_project',\n", + " part='xcu250-figd2104-2L-e' # Example FPGA part\n", + ")\n", + "\n", + "# Build and compile the HLS4ML project\n", + "hls_model.compile()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Validate the HLS model by comparing with the TensorFlow model\n", + "import numpy as np\n", + "x_test = np.random.rand(100, *model.input_shape[1:]) # Generate random test data\n", + "y_tf = model.predict(x_test)\n", + "y_hls = hls_model.predict(x_test)\n", + "\n", + "print(\"Difference:\", np.abs(y_tf - y_hls).mean()) # Check similarity\n", + "\n", + "# Generate the FPGA code\n", + "hls_model.build(csim=True) # Include C simulation\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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": "undefined.undefined.undefined" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/Data Generator.ipynb b/Computer Vision_Object Detection/Data Generator.ipynb new file mode 100644 index 0000000..d804628 --- /dev/null +++ b/Computer Vision_Object Detection/Data Generator.ipynb @@ -0,0 +1,545 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using CPU" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 226\u001b[0m\n\u001b[1;32m 223\u001b[0m dark_noise_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m/home/da886/ElectronCountingProject/1000fps_fullRolling.tif\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 225\u001b[0m \u001b[38;5;66;03m# Creating an instance of ImageProcessor\u001b[39;00m\n\u001b[0;32m--> 226\u001b[0m processor \u001b[38;5;241m=\u001b[39m \u001b[43mImageProcessor\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m30000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtiff_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdark_noise_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_electron_hits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 228\u001b[0m \u001b[38;5;66;03m# Generating images with objects \u001b[39;00m\n\u001b[1;32m 229\u001b[0m data_with_intensity_range \u001b[38;5;241m=\u001b[39m processor\u001b[38;5;241m.\u001b[39mgenerate_multiple_images()\n", + "Cell \u001b[0;32mIn[1], line 33\u001b[0m, in \u001b[0;36mImageProcessor.__init__\u001b[0;34m(self, num_to_generate, tiff_path, dark_noise_path, canvas_size, max_electron_hits)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmax_electron_hits \u001b[38;5;241m=\u001b[39m max_electron_hits\n\u001b[1;32m 32\u001b[0m \u001b[38;5;66;03m# Loads the images from the tiff file\u001b[39;00m\n\u001b[0;32m---> 33\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mimages \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload_images_from_tiff\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtiff_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 34\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdark_noise_images \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mload_images_from_tiff(dark_noise_path)\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# Creates a dark stack of the same size as the canvas\u001b[39;00m\n", + "Cell \u001b[0;32mIn[1], line 50\u001b[0m, in \u001b[0;36mImageProcessor.load_images_from_tiff\u001b[0;34m(self, tiff_path)\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m Image\u001b[38;5;241m.\u001b[39mopen(tiff_path) \u001b[38;5;28;01mas\u001b[39;00m img:\n\u001b[1;32m 49\u001b[0m images \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m---> 50\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[43mimg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mn_frames\u001b[49m):\n\u001b[1;32m 51\u001b[0m img\u001b[38;5;241m.\u001b[39mseek(i)\n\u001b[1;32m 52\u001b[0m images\u001b[38;5;241m.\u001b[39mappend(np\u001b[38;5;241m.\u001b[39marray(img))\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:1137\u001b[0m, in \u001b[0;36mTiffImageFile.n_frames\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1135\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_seek(\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_frame_pos))\n\u001b[1;32m 1136\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_n_frames \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1137\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_seek\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtell\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1138\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mseek(current)\n\u001b[1;32m 1139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_n_frames\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:1194\u001b[0m, in \u001b[0;36mTiffImageFile._seek\u001b[0;34m(self, frame)\u001b[0m\n\u001b[1;32m 1192\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtag \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mifd \u001b[38;5;241m=\u001b[39m ImageFileDirectory_v1\u001b[38;5;241m.\u001b[39mfrom_v2(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtag_v2)\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__frame \u001b[38;5;241m=\u001b[39m frame\n\u001b[0;32m-> 1194\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_setup\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:1354\u001b[0m, in \u001b[0;36mTiffImageFile._setup\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1350\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_planar_configuration \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtag_v2\u001b[38;5;241m.\u001b[39mget(PLANAR_CONFIGURATION, \u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 1352\u001b[0m \u001b[38;5;66;03m# photometric is a required tag, but not everyone is reading\u001b[39;00m\n\u001b[1;32m 1353\u001b[0m \u001b[38;5;66;03m# the specification\u001b[39;00m\n\u001b[0;32m-> 1354\u001b[0m photo \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtag_v2\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[43mPHOTOMETRIC_INTERPRETATION\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1356\u001b[0m \u001b[38;5;66;03m# old style jpeg compression images most certainly are YCbCr\u001b[39;00m\n\u001b[1;32m 1357\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compression \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtiff_jpeg\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n", + "File \u001b[0;32m:774\u001b[0m, in \u001b[0;36mget\u001b[0;34m(self, key, default)\u001b[0m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:623\u001b[0m, in \u001b[0;36mImageFileDirectory_v2.__getitem__\u001b[0;34m(self, tag)\u001b[0m\n\u001b[1;32m 621\u001b[0m typ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtagtype[tag]\n\u001b[1;32m 622\u001b[0m size, handler \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_load_dispatch[typ]\n\u001b[0;32m--> 623\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mtag\u001b[49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m handler(\u001b[38;5;28mself\u001b[39m, data, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlegacy_api) \u001b[38;5;66;03m# check type\u001b[39;00m\n\u001b[1;32m 624\u001b[0m val \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_tags_v2[tag]\n\u001b[1;32m 625\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlegacy_api \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(val, (\u001b[38;5;28mtuple\u001b[39m, \u001b[38;5;28mbytes\u001b[39m)):\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:633\u001b[0m, in \u001b[0;36mImageFileDirectory_v2.__setitem__\u001b[0;34m(self, tag, value)\u001b[0m\n\u001b[1;32m 632\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__setitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m, tag, value):\n\u001b[0;32m--> 633\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_setitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtag\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlegacy_api\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:639\u001b[0m, in \u001b[0;36mImageFileDirectory_v2._setitem\u001b[0;34m(self, tag, value, legacy_api)\u001b[0m\n\u001b[1;32m 636\u001b[0m basetypes \u001b[38;5;241m=\u001b[39m (Number, \u001b[38;5;28mbytes\u001b[39m, \u001b[38;5;28mstr\u001b[39m)\n\u001b[1;32m 638\u001b[0m info \u001b[38;5;241m=\u001b[39m TiffTags\u001b[38;5;241m.\u001b[39mlookup(tag, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgroup)\n\u001b[0;32m--> 639\u001b[0m values \u001b[38;5;241m=\u001b[39m [value] \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(value, basetypes) \u001b[38;5;28;01melse\u001b[39;00m value\n\u001b[1;32m 641\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m tag \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtagtype:\n\u001b[1;32m 642\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m info\u001b[38;5;241m.\u001b[39mtype:\n", + "File \u001b[0;32m:117\u001b[0m, in \u001b[0;36m__instancecheck__\u001b[0;34m(cls, instance)\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "import numpy as np\n", + "import random\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "import h5py\n", + "\n", + "class ImageProcessor:\n", + " \"\"\"Image generation class\"\"\" \n", + " \n", + " def __init__(self, \n", + " num_to_generate,\n", + " tiff_path, \n", + " dark_noise_path, \n", + " canvas_size = (256, 256), \n", + " max_electron_hits = 100):\n", + " \"\"\"Initializes the ImageProcessor class\n", + "\n", + " Args:\n", + " num_to_generate (int): Number of images to generate\n", + " tiff_path (str): Location of the tiff file that contains the electron hits\n", + " dark_noise_path (str): Path to the noisy data\n", + " canvas_size (tuple, optional): Size of the canvas to place the images on. Defaults to (64, 64).\n", + " max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 13.\n", + " \"\"\" \n", + " \n", + " self.tiff_path = tiff_path\n", + " self.dark_noise_path = dark_noise_path\n", + " self.canvas_size = canvas_size\n", + " self.num_to_generate = num_to_generate\n", + " self.max_electron_hits = max_electron_hits\n", + " \n", + " # Loads the images from the tiff file\n", + " self.images = self.load_images_from_tiff(tiff_path)\n", + " self.dark_noise_images = self.load_images_from_tiff(dark_noise_path)\n", + " \n", + " # Creates a dark stack of the same size as the canvas\n", + " self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + " \n", + " def load_images_from_tiff(self, tiff_path):\n", + " \"\"\"Loads the images from a tiff file\n", + "\n", + " Args:\n", + " tiff_path (str): Path to the tiff file\n", + "\n", + " Returns:\n", + " list: List of images\n", + " \"\"\" \n", + " with Image.open(tiff_path) as img:\n", + " images = []\n", + " for i in range(img.n_frames):\n", + " img.seek(i)\n", + " images.append(np.array(img))\n", + " return images\n", + " \n", + " def noisy(self, noise_typ, image): \n", + " \"\"\"Adds noise to the images\n", + " \n", + " Args:\n", + " noise_typ (str): Type of noise to add\n", + " image (numpy array): Image to add noise to\n", + " \n", + " Returns:\n", + " numpy array: Noisy image\n", + " \"\"\"\n", + " if noise_typ == \"gauss\":\n", + " row, col = image.shape\n", + " mean = 0\n", + " var = 0.0001\n", + " sigma = var ** 0.5\n", + " threshold = 8\n", + " gauss = np.random.normal(mean, sigma, (row, col))\n", + " tnoisy = image + gauss\n", + "\n", + " tnoisy[tnoisy < threshold] = 0\n", + " noisy = np.round(tnoisy)\n", + " return noisy\n", + "\n", + " def deadcorr(self, image):\n", + " \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\n", + " \n", + " Args:\n", + " image (numpy array): Image to correct\n", + " \"\"\" \n", + " temp = image.copy()\n", + " temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + " return temp\n", + "\n", + " def dark_stack(self, imgsize):\n", + " \"\"\"Creates a dark stack of the same size as the canvas.\n", + " \n", + " Args:\n", + " imgsize (int): Size of the images in the stack\n", + " \"\"\" \n", + " dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + " dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + " return dark_noise_stack_cropped\n", + "\n", + " \n", + " def place_image_on_canvas(self):\n", + " \"\"\"Places the electron hits on the canvas without specifying intensity range.\"\"\"\n", + " canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + " height, width = self.images[0].shape\n", + " max_x = self.canvas_size[1]\n", + " max_y = self.canvas_size[0]\n", + " centers = []\n", + " centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + " \n", + " for i in range(self.max_electron_hits):\n", + " x = random.randint(1 - width//2, max_x - width//2 - 1)\n", + " y = random.randint(1 - height//2, max_y - height//2 - 1)\n", + " \n", + " # Randomly select an electron hit\n", + " index = random.randint(0, 97999)\n", + " # index = 95\n", + " hit = self.images[index]\n", + " \n", + " y_min = y\n", + " y_max = y + height\n", + " x_min = x \n", + " x_max = x + width\n", + " \n", + " x_center = x + width // 2 # Correct the center calculation to be the true midpoint\n", + " y_center = y + height // 2 # Correct the center calculation to be the true midpoint\n", + " \n", + " if y_min < 0:\n", + " hit = hit[y_min*-1:, :]\n", + " y_min = 0\n", + "\n", + " if y_max > max_y:\n", + " hit = hit[:-(y_max-max_y), :]\n", + " y_max = max_y\n", + " \n", + " if x_min < 0:\n", + " hit = hit[:, x_min*-1:]\n", + " x_min = 0\n", + " \n", + " if x_max > max_x:\n", + " hit = hit[:, :-(x_max-max_x)]\n", + " x_max = max_x\n", + " \n", + " # canvas[y_min:y_max, x_min:x_max] = hit\n", + " canvas[y_min:y_max, x_min:x_max]=np.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255)\n", + " centers.append((x_center, y_center))\n", + " centers_training[i, 0] = 1\n", + " centers_training[i, 1:] = [x_center, y_center]\n", + " \n", + " # # Apply Gaussian noise\n", + " # canvas = self.noisy('gauss', canvas)\n", + " # noise_int = np.random.randint(len(self.dark_noise))\n", + " # canvas = canvas + self.dark_noise[noise_int]\n", + " canvas = canvas \n", + " \n", + " return (canvas, centers, centers_training)\n", + "\n", + " \n", + " def generate_multiple_images(self):\n", + " \"\"\"Generates multiple images without specifying intensity range for the objects.\"\"\" \n", + " results = []\n", + " for _ in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + " results.append(self.place_image_on_canvas())\n", + " return results\n", + "\n", + " \n", + " def generate_noise_only_images(self, num_images):\n", + " \"\"\"Generates images containing only noise, with no electron hits.\n", + "\n", + " Args:\n", + " num_images (int): Number of noise-only images to generate.\n", + "\n", + " Returns:\n", + " list: List of generated noise-only images.\n", + " \"\"\"\n", + " noise_images = []\n", + " for _ in tqdm(range(num_images), desc=\"Generating noise-only images\"):\n", + " # Create an empty canvas\n", + " canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "\n", + " # Apply Gaussian noise\n", + " canvas = self.noisy('gauss', canvas)\n", + "\n", + " # Add dark noise\n", + " noise_int = np.random.randint(len(self.dark_noise))\n", + " canvas = canvas + self.dark_noise[noise_int]\n", + "\n", + " noise_images.append(canvas)\n", + "\n", + " return noise_images\n", + " \n", + " def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + " \"\"\"Mixes object-containing images with noise-only images and saves to an HDF5 file\n", + " \n", + " Args:\n", + " data_with_objects (list): List of data with objects to save.\n", + " noise_images (list): List of noise-only images to save.\n", + " filename (str): Path to the HDF5 file.\n", + " \"\"\"\n", + " total_images = len(data_with_objects) + len(noise_images)\n", + " combined_data = []\n", + "\n", + " # Add labels: 1 for images with objects, 0 for noise-only images\n", + " for item in data_with_objects:\n", + " combined_data.append((item[0], item[2], 1)) # 1 indicates it contains objects\n", + " \n", + " for noise_image in noise_images:\n", + " combined_data.append((noise_image, np.zeros((100, 3)), 0)) # 0 indicates noise-only\n", + " \n", + " # Shuffle the combined data\n", + " random.shuffle(combined_data)\n", + "\n", + " # Save to HDF5 file\n", + " with h5py.File(filename, 'w') as h5_file:\n", + " theimages = h5_file.create_dataset('images', shape=(total_images, 256, 256), dtype='uint8')\n", + " thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 100, 3), dtype='float32')\n", + " labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + " for i, (image, center, label) in enumerate(combined_data):\n", + " theimages[i] = image\n", + " thecenters[i] = center\n", + " labels[i] = label\n", + "\n", + "\n", + "tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# Creating an instance of ImageProcessor\n", + "processor = ImageProcessor(30000, tiff_path, dark_noise_path, max_electron_hits=100)\n", + "\n", + "# Generating images with objects \n", + "data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# Generating noise-only images\n", + "noise_only_images = processor.generate_noise_only_images(0)\n", + "\n", + "# Save mixed dataset to an HDF5 file\n", + "processor.save_mixed_images_to_h5(data_with_intensity_range, noise_only_images, '/home/da886/Computer Vision_Object Detection/Data/30KFixed_100_256by256_RandomindexNoNoise.h5')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using GPU" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating images: 100%|██████████| 30000/30000 [13:20<00:00, 37.47it/s]\n" + ] + } + ], + "source": [ + "import cupy as cp\n", + "import random\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "import h5py\n", + "\n", + "class ImageProcessorGPU:\n", + " \"\"\"Image generation class with GPU acceleration\"\"\" \n", + "\n", + " def __init__(self, \n", + " num_to_generate,\n", + " tiff_path, \n", + " dark_noise_path, \n", + " canvas_size=(256, 256), \n", + " max_electron_hits=100):\n", + " \"\"\"Initializes the ImageProcessorGPU class\n", + "\n", + " Args:\n", + " num_to_generate (int): Number of images to generate\n", + " tiff_path (str): Location of the tiff file that contains the electron hits\n", + " dark_noise_path (str): Path to the noisy data\n", + " canvas_size (tuple, optional): Size of the canvas to place the images on. Defaults to (64, 64).\n", + " max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 13.\n", + " \"\"\" \n", + " self.tiff_path = tiff_path\n", + " self.dark_noise_path = dark_noise_path\n", + " self.canvas_size = canvas_size\n", + " self.num_to_generate = num_to_generate\n", + " self.max_electron_hits = max_electron_hits\n", + "\n", + " # Loads the images from the tiff file\n", + " self.images = cp.asarray(self.load_images_from_tiff(tiff_path))\n", + " self.dark_noise_images = cp.asarray(self.load_images_from_tiff(dark_noise_path))\n", + "\n", + " # Creates a dark stack of the same size as the canvas\n", + " self.dark_noise = cp.asarray(self.dark_stack(self.canvas_size[0]))\n", + "\n", + " def load_images_from_tiff(self, tiff_path):\n", + " \"\"\"Loads the images from a tiff file\n", + "\n", + " Args:\n", + " tiff_path (str): Path to the tiff file\n", + "\n", + " Returns:\n", + " list: List of images\n", + " \"\"\" \n", + " with Image.open(tiff_path) as img:\n", + " images = []\n", + " for i in range(img.n_frames):\n", + " img.seek(i)\n", + " images.append(cp.array(img))\n", + " return images\n", + "\n", + " def noisy(self, noise_typ, image): \n", + " \"\"\"Adds noise to the images\n", + " \n", + " Args:\n", + " noise_typ (str): Type of noise to add\n", + " image (CuPy array): Image to add noise to\n", + " \n", + " Returns:\n", + " CuPy array: Noisy image\n", + " \"\"\"\n", + " if noise_typ == \"gauss\":\n", + " row, col = image.shape\n", + " mean = 0\n", + " var = 0.0001\n", + " sigma = var ** 0.5\n", + " threshold = 8\n", + " gauss = cp.random.normal(mean, sigma, (row, col))\n", + " tnoisy = image + gauss\n", + "\n", + " tnoisy[tnoisy < threshold] = 0\n", + " noisy = cp.round(tnoisy)\n", + " return noisy\n", + "\n", + " def deadcorr(self, image):\n", + " \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\n", + " \n", + " Args:\n", + " image (CuPy array): Image to correct\n", + " \"\"\" \n", + " temp = image.copy()\n", + " temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + " return temp\n", + "\n", + " def dark_stack(self, imgsize):\n", + " \"\"\"Creates a dark stack of the same size as the canvas.\n", + " \n", + " Args:\n", + " imgsize (int): Size of the images in the stack\n", + " \"\"\" \n", + " dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + " dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + " return dark_noise_stack_cropped\n", + "\n", + " def place_image_on_canvas(self):\n", + " \"\"\"Places the electron hits on the canvas without specifying intensity range.\"\"\"\n", + " canvas = cp.zeros(self.canvas_size, dtype=cp.uint8)\n", + " height, width = self.images[0].shape\n", + " max_x = self.canvas_size[1]\n", + " max_y = self.canvas_size[0]\n", + " centers = []\n", + " centers_training = cp.zeros((self.max_electron_hits, 3), dtype=cp.float32)\n", + "\n", + " for i in range(self.max_electron_hits):\n", + " x = random.randint(1 - width // 2, max_x - width // 2 - 1)\n", + " y = random.randint(1 - height // 2, max_y - height // 2 - 1)\n", + "\n", + " # Randomly select an electron hit\n", + " index = random.randint(0, len(self.images) - 1)\n", + " hit = self.images[index]\n", + "\n", + " y_min = y\n", + " y_max = y + height\n", + " x_min = x \n", + " x_max = x + width\n", + "\n", + " x_center = x + width // 2\n", + " y_center = y + height // 2\n", + "\n", + " if y_min < 0:\n", + " hit = hit[y_min*-1:, :]\n", + " y_min = 0\n", + "\n", + " if y_max > max_y:\n", + " hit = hit[:-(y_max-max_y), :]\n", + " y_max = max_y\n", + "\n", + " if x_min < 0:\n", + " hit = hit[:, x_min*-1:]\n", + " x_min = 0\n", + "\n", + " if x_max > max_x:\n", + " hit = hit[:, :-(x_max-max_x)]\n", + " x_max = max_x\n", + "\n", + " canvas[y_min:y_max, x_min:x_max] = cp.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255)\n", + " centers.append((x_center, y_center))\n", + " centers_training[i, 0] = 1\n", + " centers_training[i, 1:] = cp.array([x_center, y_center]) # Fixed line\n", + "\n", + " canvas = self.noisy('gauss', canvas)\n", + " noise_int = random.randint(0, len(self.dark_noise) - 1)\n", + " canvas += self.dark_noise[noise_int]\n", + "\n", + " return (cp.asnumpy(canvas), centers, cp.asnumpy(centers_training))\n", + "\n", + "\n", + " def generate_multiple_images(self):\n", + " \"\"\"Generates multiple images without specifying intensity range for the objects.\"\"\" \n", + " results = []\n", + " for _ in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + " results.append(self.place_image_on_canvas())\n", + " return results\n", + "\n", + " def generate_noise_only_images(self, num_images):\n", + " \"\"\"Generates images containing only noise, with no electron hits.\n", + "\n", + " Args:\n", + " num_images (int): Number of noise-only images to generate.\n", + "\n", + " Returns:\n", + " list: List of generated noise-only images.\n", + " \"\"\"\n", + " noise_images = []\n", + " for _ in tqdm(range(num_images), desc=\"Generating noise-only images\"):\n", + " canvas = cp.zeros(self.canvas_size, dtype=cp.uint8)\n", + " canvas = self.noisy('gauss', canvas)\n", + " noise_int = random.randint(0, len(self.dark_noise) - 1)\n", + " canvas += self.dark_noise[noise_int]\n", + " noise_images.append(cp.asnumpy(canvas))\n", + "\n", + " return noise_images\n", + "\n", + " def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + " \"\"\"Mixes object-containing images with noise-only images and saves to an HDF5 file\n", + " \n", + " Args:\n", + " data_with_objects (list): List of data with objects to save.\n", + " noise_images (list): List of noise-only images to save.\n", + " filename (str): Path to the HDF5 file.\n", + " \"\"\"\n", + " total_images = len(data_with_objects) + len(noise_images)\n", + " combined_data = []\n", + "\n", + " for item in data_with_objects:\n", + " combined_data.append((item[0], item[2], 1))\n", + " \n", + " for noise_image in noise_images:\n", + " combined_data.append((noise_image, cp.zeros((100, 3)), 0))\n", + "\n", + " random.shuffle(combined_data)\n", + "\n", + " with h5py.File(filename, 'w') as h5_file:\n", + " theimages = h5_file.create_dataset('images', shape=(total_images, 256, 256), dtype='uint8')\n", + " thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 100, 3), dtype='float32')\n", + " labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + " for i, (image, center,label) in enumerate(combined_data):\n", + " theimages[i] = image\n", + " thecenters[i] = center\n", + " labels[i] = label\n", + "\n", + "\n", + "# Example usage\n", + "tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "processor = ImageProcessorGPU(30000, tiff_path, dark_noise_path, max_electron_hits=100)\n", + "\n", + "# Generate images with objects\n", + "data_with_objects = processor.generate_multiple_images()\n", + "\n", + "# Generate noise-only images (if none are needed, pass an empty list)\n", + "noise_images = []\n", + "\n", + "# Save mixed dataset to an HDF5 file\n", + "processor.save_mixed_images_to_h5(data_with_objects, noise_images, '/home/da886/Computer Vision_Object Detection/Data/30KFixed_100_256by256_RandomindexNoNoise.h5')\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/Hungarian Algorithm.ipynb b/Computer Vision_Object Detection/Hungarian Algorithm.ipynb new file mode 100644 index 0000000..2d6e31d --- /dev/null +++ b/Computer Vision_Object Detection/Hungarian Algorithm.ipynb @@ -0,0 +1,4618 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 14:56:44.594060: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-22 14:56:44.606681: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-22 14:56:44.619071: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-22 14:56:44.622792: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-22 14:56:44.633664: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-22 14:56:45.338636: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:4',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 14:56:46.568929: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:4f:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"4\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:4\"]) # The GPUs will be in the order of the list\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def create_datasets(data_loader, train_size=0.95):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + " val_images_flat = val_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + "\n", + " # Flatten centers to match tiles\n", + " train_centers_flat = train_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + " val_centers_flat = val_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # Create TensorFlow datasets\n", + " batch_size = 100\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).shuffle(buffer_size=1024*200, reshuffle_each_iteration=True).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/100Fixed_100_256by256_TestData_RandomindexNoNoise.h5' \n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0.25, 0.25],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,100)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + " outputs = layers.Dense(max_hits * 2, activation='linear')(x)\n", + " outputs = layers.Reshape((max_hits, 2))(outputs) # Match the shape of labels\n", + "\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((95, 1024, 8, 8), (5, 1024, 8, 8), (95, 1024, 2, 2), (5, 1024, 2, 2))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "def hungarian_loss(y_true, y_pred):\n", + " \"\"\"\n", + " TensorFlow-compatible Hungarian loss function.\n", + "\n", + " Args:\n", + " y_true: Tensor of shape [batch_size, max_hits_per_tile, 2], true hit coordinates (normalized).\n", + " y_pred: Tensor of shape [batch_size, max_hits_per_tile, 2], predicted hit coordinates (normalized).\n", + "\n", + " Returns:\n", + " loss: Scalar tensor, combined loss value across the batch.\n", + " \"\"\"\n", + " batch_size = tf.shape(y_true)[0]\n", + " max_hits = tf.shape(y_true)[1]\n", + "\n", + " def compute_cost_matrix(true_hits, pred_hits):\n", + " # Compute pairwise squared L2 distances\n", + " true_hits_expanded = tf.expand_dims(true_hits, axis=1) # [max_hits, 1, 2]\n", + " pred_hits_expanded = tf.expand_dims(pred_hits, axis=0) # [1, max_hits, 2]\n", + " cost_matrix = tf.reduce_sum((true_hits_expanded - pred_hits_expanded) ** 2, axis=-1)\n", + " return cost_matrix\n", + "\n", + " def hungarian_loss_per_sample(true_hits, pred_hits):\n", + " cost_matrix = compute_cost_matrix(true_hits, pred_hits)\n", + " # Use linear_sum_assignment-like approach in TensorFlow to find minimum assignment\n", + " row_indices, col_indices = tf.experimental.numpy.unravel_index(\n", + " tf.argsort(tf.reshape(cost_matrix, [-1]))[:max_hits],\n", + " [max_hits, max_hits]\n", + " )\n", + " assigned_costs = tf.gather_nd(cost_matrix, tf.stack([row_indices, col_indices], axis=1))\n", + " return tf.reduce_sum(assigned_costs)\n", + "\n", + " # Apply the Hungarian loss for each sample in the batch\n", + " batch_losses = tf.map_fn(\n", + " lambda x: hungarian_loss_per_sample(x[0], x[1]),\n", + " (y_true, y_pred),\n", + " dtype=tf.float32\n", + " )\n", + "\n", + " return tf.reduce_mean(batch_losses)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional_2\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional_2\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_2 (InputLayer)      │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_4 (Conv2D)               │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_2 (MaxPooling2D)  │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_5 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_2 (Flatten)             │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_4 (Dense)                 │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_5 (Dense)                 │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape_2 (Reshape)             │ (None, 2, 2)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_2 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_4 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_5 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_2 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_4 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_5 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape_2 (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(optimizer = 'adam', loss= hungarian_loss)\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<_BatchDataset element_spec=(TensorSpec(shape=(None, 8, 8, 1), dtype=tf.float64, name=None), TensorSpec(shape=(None, 2, 2), dtype=tf.float64, name=None))>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Error reported to Coordinator: module 'tensorflow._api.v2.experimental.numpy' has no attribute 'unravel_index'\n", + "Traceback (most recent call last):\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/training/coordinator.py\", line 293, in stop_on_exception\n", + " yield\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/mirrored_run.py\", line 387, in run\n", + " self.main_result = self.main_fn(*self.main_args, **self.main_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/autograph/impl/api.py\", line 643, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data\n", + " return self.train_step(data)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 54, in train_step\n", + " loss = self._compute_loss(\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/trainer.py\", line 357, in _compute_loss\n", + " return self.compute_loss(\n", + " ^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/trainer.py\", line 325, in compute_loss\n", + " loss = self._compile_loss(y, y_pred, sample_weight)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/compile_utils.py\", line 609, in __call__\n", + " return self.call(y_true, y_pred, sample_weight)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/compile_utils.py\", line 645, in call\n", + " loss(y_t, y_p, sample_weight), dtype=backend.floatx()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/losses/loss.py\", line 43, in __call__\n", + " losses = self.call(y_true, y_pred)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/losses/losses.py\", line 27, in call\n", + " return self.fn(y_true, y_pred, **self._fn_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/tmp/ipykernel_2631622/1269987198.py\", line 35, in hungarian_loss\n", + " batch_losses = tf.map_fn(\n", + " ^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/util/deprecation.py\", line 660, in new_func\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/util/deprecation.py\", line 588, in new_func\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/ops/map_fn.py\", line 637, in map_fn_v2\n", + " return map_fn(\n", + " ^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/util/deprecation.py\", line 588, in new_func\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/ops/map_fn.py\", line 497, in map_fn\n", + " _, r_a = while_loop.while_loop(\n", + " ^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/ops/while_loop.py\", line 440, in while_loop\n", + " return while_v2.while_loop(\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/ops/while_v2.py\", line 202, in while_loop\n", + " body_graph = func_graph_module.func_graph_from_py_func(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/framework/func_graph.py\", line 1059, in func_graph_from_py_func\n", + " func_outputs = python_func(*func_args, **func_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/ops/while_v2.py\", line 180, in wrapped_body\n", + " outputs = body(\n", + " ^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/ops/map_fn.py\", line 487, in compute\n", + " result_value = autographed_fn(elems_value)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/autograph/impl/api.py\", line 643, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/tmp/ipykernel_2631622/1269987198.py\", line 36, in \n", + " lambda x: hungarian_loss_per_sample(x[0], x[1]),\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/tmp/ipykernel_2631622/1269987198.py\", line 27, in hungarian_loss_per_sample\n", + " row_indices, col_indices = tf.experimental.numpy.unravel_index(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "AttributeError: module 'tensorflow._api.v2.experimental.numpy' has no attribute 'unravel_index'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:00:21.595037: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "in user code:\n\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data **\n return self.train_step(data)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 54, in train_step\n loss = self._compute_loss(\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/trainer.py\", line 357, in _compute_loss\n return self.compute_loss(\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/trainer.py\", line 325, in compute_loss\n loss = self._compile_loss(y, y_pred, sample_weight)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/compile_utils.py\", line 609, in __call__\n return self.call(y_true, y_pred, sample_weight)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/compile_utils.py\", line 645, in call\n loss(y_t, y_p, sample_weight), dtype=backend.floatx()\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/losses/loss.py\", line 43, in __call__\n losses = self.call(y_true, y_pred)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/losses/losses.py\", line 27, in call\n return self.fn(y_true, y_pred, **self._fn_kwargs)\n File \"/tmp/ipykernel_2631622/1269987198.py\", line 35, in hungarian_loss\n batch_losses = tf.map_fn(\n File \"/tmp/ipykernel_2631622/1269987198.py\", line 36, in **\n lambda x: hungarian_loss_per_sample(x[0], x[1]),\n File \"/tmp/ipykernel_2631622/1269987198.py\", line 27, in hungarian_loss_per_sample\n row_indices, col_indices = tf.experimental.numpy.unravel_index(\n\n AttributeError: module 'tensorflow._api.v2.experimental.numpy' has no attribute 'unravel_index'\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[14], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mlr_scheduler\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py:122\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 119\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m 120\u001b[0m \u001b[38;5;66;03m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m 121\u001b[0m \u001b[38;5;66;03m# `keras.config.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m--> 122\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 123\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m/tmp/__autograph_generated_file26zlw07b.py:14\u001b[0m, in \u001b[0;36mouter_factory..inner_factory..tf__wrapped_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 13\u001b[0m do_return \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m retval_ \u001b[38;5;241m=\u001b[39m ag__\u001b[38;5;241m.\u001b[39mconverted_call(ag__\u001b[38;5;241m.\u001b[39mld(call_for_each_replica), (ag__\u001b[38;5;241m.\u001b[39mld(strategy), ag__\u001b[38;5;241m.\u001b[39mld(fn)\u001b[38;5;241m.\u001b[39mpython_function, ag__\u001b[38;5;241m.\u001b[39mld(args), ag__\u001b[38;5;241m.\u001b[39mld(kwargs)), \u001b[38;5;28;01mNone\u001b[39;00m, fscope)\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m:\n\u001b[1;32m 16\u001b[0m do_return \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "Cell \u001b[0;32mIn[12], line 35\u001b[0m, in \u001b[0;36mhungarian_loss\u001b[0;34m(y_true, y_pred)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mreduce_sum(assigned_costs)\n\u001b[1;32m 34\u001b[0m \u001b[38;5;66;03m# Apply the Hungarian loss for each sample in the batch\u001b[39;00m\n\u001b[0;32m---> 35\u001b[0m batch_losses \u001b[38;5;241m=\u001b[39m \u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmap_fn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 36\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mhungarian_loss_per_sample\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 37\u001b[0m \u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43my_true\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_pred\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 38\u001b[0m \u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat32\u001b[49m\n\u001b[1;32m 39\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mreduce_mean(batch_losses)\n", + "Cell \u001b[0;32mIn[12], line 36\u001b[0m, in \u001b[0;36mhungarian_loss..\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mreduce_sum(assigned_costs)\n\u001b[1;32m 34\u001b[0m \u001b[38;5;66;03m# Apply the Hungarian loss for each sample in the batch\u001b[39;00m\n\u001b[1;32m 35\u001b[0m batch_losses \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mmap_fn(\n\u001b[0;32m---> 36\u001b[0m \u001b[38;5;28;01mlambda\u001b[39;00m x: \u001b[43mhungarian_loss_per_sample\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 37\u001b[0m (y_true, y_pred),\n\u001b[1;32m 38\u001b[0m dtype\u001b[38;5;241m=\u001b[39mtf\u001b[38;5;241m.\u001b[39mfloat32\n\u001b[1;32m 39\u001b[0m )\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mreduce_mean(batch_losses)\n", + "Cell \u001b[0;32mIn[12], line 27\u001b[0m, in \u001b[0;36mhungarian_loss..hungarian_loss_per_sample\u001b[0;34m(true_hits, pred_hits)\u001b[0m\n\u001b[1;32m 25\u001b[0m cost_matrix \u001b[38;5;241m=\u001b[39m compute_cost_matrix(true_hits, pred_hits)\n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# Use linear_sum_assignment-like approach in TensorFlow to find minimum assignment\u001b[39;00m\n\u001b[0;32m---> 27\u001b[0m row_indices, col_indices \u001b[38;5;241m=\u001b[39m \u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexperimental\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnumpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munravel_index\u001b[49m(\n\u001b[1;32m 28\u001b[0m tf\u001b[38;5;241m.\u001b[39margsort(tf\u001b[38;5;241m.\u001b[39mreshape(cost_matrix, [\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]))[:max_hits],\n\u001b[1;32m 29\u001b[0m [max_hits, max_hits]\n\u001b[1;32m 30\u001b[0m )\n\u001b[1;32m 31\u001b[0m assigned_costs \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mgather_nd(cost_matrix, tf\u001b[38;5;241m.\u001b[39mstack([row_indices, col_indices], axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m 32\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mreduce_sum(assigned_costs)\n", + "\u001b[0;31mAttributeError\u001b[0m: in user code:\n\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data **\n return self.train_step(data)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 54, in train_step\n loss = self._compute_loss(\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/trainer.py\", line 357, in _compute_loss\n return self.compute_loss(\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/trainer.py\", line 325, in compute_loss\n loss = self._compile_loss(y, y_pred, sample_weight)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/compile_utils.py\", line 609, in __call__\n return self.call(y_true, y_pred, sample_weight)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/trainers/compile_utils.py\", line 645, in call\n loss(y_t, y_p, sample_weight), dtype=backend.floatx()\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/losses/loss.py\", line 43, in __call__\n losses = self.call(y_true, y_pred)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/losses/losses.py\", line 27, in call\n return self.fn(y_true, y_pred, **self._fn_kwargs)\n File \"/tmp/ipykernel_2631622/1269987198.py\", line 35, in hungarian_loss\n batch_losses = tf.map_fn(\n File \"/tmp/ipykernel_2631622/1269987198.py\", line 36, in **\n lambda x: hungarian_loss_per_sample(x[0], x[1]),\n File \"/tmp/ipykernel_2631622/1269987198.py\", line 27, in hungarian_loss_per_sample\n row_indices, col_indices = tf.experimental.numpy.unravel_index(\n\n AttributeError: module 'tensorflow._api.v2.experimental.numpy' has no attribute 'unravel_index'\n" + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=100,\n", + " \n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/Jan 21 weights/30KFixed_100_256by256_RandomindexNoNoise.h5_linear_custom_HungarianLoss.keras')\n", + "loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/Jan 21 weights/30KFixed_100_256by256_RandomindexNoNoise.h5_linear_custom_HungarianLoss.keras')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m640/640\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 650us/step\n", + "Predicted centers shape: (20, 1024, 2, 2)\n", + "Grouped targets shape: (20, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "# # # # Flatten validation images and centers\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "\n", + "# Batch size for n images\n", + "batch = 20* 1024 # number of images per batch\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch)\n", + "# Make predictions on dataset\n", + "# inputs, targets = next(iter(val_dataset)) # Extract a batch\n", + "inputs, targets = next(iter(train_dataset)) # Extract a batch\n", + "outputs = loaded_model.predict(inputs)\n", + "\n", + "# Reshape predictions and targets back to image structure\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 2)\n", + "\n", + "# Print the shapes\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\") # (batch_size // 1024, 1024, 2, 2)\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\") # (batch_size // 1024, 1024, 2, 2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 6:\n", + "Tile 0: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 4: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 5: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 6: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 7: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 11: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 18: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 23: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 24: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 28: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 29: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 30: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 31: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 34: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 35: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[-0.00212616 -0.00132895]\n", + " [ 0.6148609 0.15202513]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 37: Predicted: [[ 5.3350430e-04 -5.1296954e-03]\n", + " [ 1.3150854e-01 5.7588255e-01]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 38: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 44: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 46: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 48: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 49: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 51: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 53: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[0.01131032 0.00122316]\n", + " [0.4542928 0.38000754]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 55: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 59: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 61: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[0.01750568 0.01781563]\n", + " [0.16858102 0.77510613]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 63: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 64: Predicted: [[-3.0364958e-05 -1.5066494e-03]\n", + " [ 6.7907917e-01 3.7127927e-01]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 65: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 66: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 67: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 68: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 69: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 71: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 73: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[0.01902999 0.00928505]\n", + " [0.37635323 0.79470265]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 76: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 77: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 80: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 85: Predicted: [[-0.00838776 -0.00466457]\n", + " [ 0.11400427 0.22932242]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 86: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 87: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 88: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 90: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 91: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 92: Predicted: [[0.01023997 0.01098237]\n", + " [0.04090108 0.7854294 ]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 93: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 95: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 96: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[0.01392685 0.0071429 ]\n", + " [0.3856735 0.5067542 ]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 98: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 99: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 100: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 102: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 103: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 106: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[ 0.00453585 -0.00106453]\n", + " [ 0.32053998 0.00692242]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 108: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 111: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 112: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 113: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 114: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 118: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 119: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 120: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 122: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 124: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 126: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 127: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 129: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 131: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 134: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[0.01140308 0.0446682 ]\n", + " [0.6393117 0.37893972]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 140: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 141: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 142: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 143: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 145: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 147: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[0.00763885 0.01559704]\n", + " [0.416132 0.13884915]], True: [[0.5 0.125]\n", + " [0. 0. ]]\n", + "Tile 149: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 151: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 155: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[-0.00304792 -0.00621453]\n", + " [ 0.73600227 0.09381156]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 160: Predicted: [[0.00156659 0.00210473]\n", + " [0.737751 0.00674172]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 161: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 162: Predicted: [[-0.00379951 0.00089147]\n", + " [ 0.19934507 0.00996793]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 164: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 165: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 166: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 167: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 169: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 171: Predicted: [[0.00525455 0.00451468]\n", + " [0.4265897 0.4938782 ]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 172: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 174: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 179: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 180: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 182: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 184: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[0.01046152 0.00875208]\n", + " [0.03406421 0.70839226]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 186: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 188: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 190: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 192: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 194: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 196: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[-0.00683747 0.00171091]\n", + " [ 0.47313452 0.6082742 ]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 198: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 199: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 201: Predicted: [[-0.00073414 0.00412319]\n", + " [ 0.05256875 0.4925893 ]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 202: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 205: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 206: Predicted: [[0.0126046 0.01698836]\n", + " [0.65652484 0.3795855 ]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 207: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 210: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 211: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 212: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 213: Predicted: [[0.01238255 0.0070883 ]\n", + " [0.4885625 0.7298824 ]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 214: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 215: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 216: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 217: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 218: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 219: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 220: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[0.31469083 0.09317267]\n", + " [0.5177793 0.5635565 ]], True: [[0.875 0.75 ]\n", + " [0.375 0.5 ]]\n", + "Tile 222: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 225: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 226: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 227: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 228: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 230: Predicted: [[6.6372901e-03 3.4111133e-04]\n", + " [2.5020409e-01 5.0741154e-01]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 231: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 234: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 236: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 237: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 238: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 239: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 240: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 241: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 242: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 244: Predicted: [[-4.8860547e-04 3.2907869e-03]\n", + " [ 6.5672863e-01 5.2169889e-01]], True: [[0.625 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 245: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 246: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 247: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 249: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 253: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 254: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 255: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 257: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 258: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 259: Predicted: [[0.01193048 0.00623409]\n", + " [0.64688325 0.7402901 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 262: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[0.01317255 0.00725808]\n", + " [0.37400398 0.61794794]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 264: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 266: Predicted: [[ 0.00150957 -0.00029786]\n", + " [ 0.00702711 0.00982725]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 267: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 268: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 272: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 273: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 274: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 278: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 279: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 280: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 281: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 283: Predicted: [[-0.00196054 -0.01215046]\n", + " [ 0.48101097 0.13564049]], True: [[0.5 0.125]\n", + " [0. 0. ]]\n", + "Tile 284: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 286: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 287: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 288: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 290: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 291: Predicted: [[0.00219292 0.00163779]\n", + " [0.28943563 0.0066066 ]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 292: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 293: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 294: Predicted: [[-0.00087375 -0.00219318]\n", + " [ 0.660327 0.01481608]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 295: Predicted: [[0.00115479 0.00095016]\n", + " [0.00094657 0.00028056]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 296: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 297: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 298: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 299: Predicted: [[-0.00083462 -0.00399526]\n", + " [ 0.61525637 0.64863455]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 300: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 302: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 303: Predicted: [[0.00289541 0.00633498]\n", + " [0.11844673 0.06864414]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 304: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 305: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[0.02067721 0.04562532]\n", + " [0.03411992 0.48548457]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 307: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 309: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 310: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 311: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[ 0.00891667 -0.00093187]\n", + " [ 0.11893068 0.74225515]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 313: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 314: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 315: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 317: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 318: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 320: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 321: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 325: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 328: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 330: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[-0.00581388 -0.00858321]\n", + " [ 0.6114321 0.01233804]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 333: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 334: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 336: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 337: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 338: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 339: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 340: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 342: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[0.00392748 0.0051787 ]\n", + " [0.5082934 0.2523605 ]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 344: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 345: Predicted: [[0.00076253 0.0027609 ]\n", + " [0.38392004 0.01317583]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[0.00349821 0.00760933]\n", + " [0.01296085 0.02933558]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 347: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 349: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 350: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 351: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[-0.00084087 0.00257282]\n", + " [ 0.7354341 0.70355856]], True: [[0.75 0.75]\n", + " [0. 0. ]]\n", + "Tile 353: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 354: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 355: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 356: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 362: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 365: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 366: Predicted: [[0.06076743 0.07495584]\n", + " [0.45093748 0.4100644 ]], True: [[0.625 0.5 ]\n", + " [0.25 0.25 ]]\n", + "Tile 367: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 369: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 370: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 371: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 372: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 374: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 375: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 378: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 380: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 381: Predicted: [[0.02168027 0.02102844]\n", + " [0.7321807 0.79104143]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 382: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 383: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 384: Predicted: [[0.00057868 0.00123533]\n", + " [0.0975845 0.00835601]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 385: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 386: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 388: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 389: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 393: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 395: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 396: Predicted: [[-0.00289986 -0.00897037]\n", + " [ 0.60104924 0.14329092]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 397: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 398: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 399: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 405: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 407: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 408: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 411: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 412: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 414: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 416: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 419: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 423: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 424: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 425: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 429: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 437: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[0.00742842 0.010458 ]\n", + " [0.29679626 0.61598974]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 441: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 443: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 449: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 451: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 453: Predicted: [[-0.0064043 -0.00181993]\n", + " [ 0.730871 0.49162585]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 454: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 457: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 458: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 459: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 460: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 462: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 466: Predicted: [[0.00317425 0.00851389]\n", + " [0.3098719 0.43690532]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 467: Predicted: [[0.00279906 0.00726543]\n", + " [0.26498428 0.42950386]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 468: Predicted: [[-2.8171754e-03 -3.9577950e-05]\n", + " [ 2.6934147e-01 1.5869854e-01]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 469: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 470: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 471: Predicted: [[0.01271236 0.00585701]\n", + " [0.82725304 0.07090035]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 472: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 478: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 481: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 482: Predicted: [[0.01117839 0.00830865]\n", + " [0.50245434 0.6066849 ]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 483: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 486: Predicted: [[-0.00100278 0.00069758]\n", + " [ 0.22173044 0.15383193]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 487: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 490: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 492: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 493: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 495: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 496: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 497: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 499: Predicted: [[-0.00751386 -0.0013413 ]\n", + " [ 0.22054744 0.00522571]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 500: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 505: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 507: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[0.01233262 0.01002578]\n", + " [0.76213974 0.29363516]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 509: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 512: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 513: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[-0.00035259 -0.00030045]\n", + " [ 0.23414476 -0.00295997]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 517: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 519: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 522: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 523: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 524: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 526: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[0.01495793 0.01714808]\n", + " [0.77316004 0.7147349 ]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 529: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 530: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 535: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 536: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 538: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[ 1.9320368e-04 -2.7637789e-04]\n", + " [ 3.3340788e-01 1.8005793e-01]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 542: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 543: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 544: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 548: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 549: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 552: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 554: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 556: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 558: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[-0.004898 0.00564018]\n", + " [ 0.53594524 0.2555448 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 560: Predicted: [[0.00242518 0.00348526]\n", + " [0.04572954 0.13126224]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 561: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 562: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 563: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 565: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 566: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 567: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 568: Predicted: [[0.02235426 0.02255605]\n", + " [0.23634213 0.78764886]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 569: Predicted: [[0.00349201 0.00386336]\n", + " [0.10760779 0.08429302]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 570: Predicted: [[0.0180954 0.01462453]\n", + " [0.62454677 0.68503106]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 571: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 572: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 579: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 582: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 583: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 584: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 585: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 590: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 592: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 594: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 596: Predicted: [[ 0.0083967 -0.00597824]\n", + " [ 0.7228488 0.54038954]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 597: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 598: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[-0.00457643 -0.000791 ]\n", + " [ 0.63616496 0.49165487]], True: [[0.625 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 600: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[0.0012016 0.00102902]\n", + " [0.00075982 0.00156576]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 602: Predicted: [[0.00663129 0.00195221]\n", + " [0.1009598 0.4728011 ]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 603: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 604: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 605: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 606: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 608: Predicted: [[0.0011628 0.00739788]\n", + " [0.7392621 0.2115938 ]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 609: Predicted: [[0.00835873 0.00188535]\n", + " [0.12185314 0.7367643 ]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 610: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 613: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 617: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 618: Predicted: [[0.00515137 0.00933158]\n", + " [0.50846374 0.40990064]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 619: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 620: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[0.00758217 0.00441707]\n", + " [0.1187487 0.694864 ]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 622: Predicted: [[0.0049635 0.00295084]\n", + " [0.65589416 0.5273702 ]], True: [[0.625 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 623: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 625: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 626: Predicted: [[ 0.01503754 0.00815772]\n", + " [-0.00673757 0.54481673]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 627: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 628: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 633: Predicted: [[-0.00797356 -0.00543966]\n", + " [ 0.6931962 0.40355045]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 634: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 635: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 641: Predicted: [[-0.00477011 -0.00227241]\n", + " [ 0.74521923 0.36050168]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 642: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 643: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 645: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 647: Predicted: [[ 0.01647331 -0.00178671]\n", + " [ 0.25025406 0.7509075 ]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 648: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 649: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 650: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 651: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 652: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 653: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 654: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 657: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 659: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 660: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 662: Predicted: [[ 0.01196474 -0.00096307]\n", + " [ 0.09762833 0.6003987 ]], True: [[0.125 0.625]\n", + " [0. 0. ]]\n", + "Tile 663: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 667: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 674: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 676: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 677: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 679: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 688: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[5.4438598e-03 4.9418164e-04]\n", + " [6.4398569e-01 5.3762436e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[2.3526873e-04 1.9946075e-03]\n", + " [9.0398341e-03 2.7761784e-01]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 693: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 694: Predicted: [[-0.00068748 0.00153582]\n", + " [ 0.40653154 0.04376549]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 695: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 698: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 699: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 700: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 701: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 705: Predicted: [[ 0.00755272 -0.00388455]\n", + " [ 0.76469475 0.36122152]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 706: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 708: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 710: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 711: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 712: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 713: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[0.01727094 0.00889188]\n", + " [0.74956113 0.28671366]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 715: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 716: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 717: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 718: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 722: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 723: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 724: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[-3.0279416e-03 -2.1421211e-04]\n", + " [ 4.5380449e-01 3.7904692e-01]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 726: Predicted: [[3.3194188e-04 3.8619922e-03]\n", + " [1.6255334e-02 3.4350663e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 727: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[0.0037837 0.0031483 ]\n", + " [0.01122523 0.10625199]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 729: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 730: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 731: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 733: Predicted: [[-0.00228187 0.00368713]\n", + " [ 0.43981043 0.0107518 ]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 734: Predicted: [[0.00670691 0.0032475 ]\n", + " [0.65465117 0.5373472 ]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 735: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 741: Predicted: [[0.12063111 0.32707724]\n", + " [0.43699667 0.7260279 ]], True: [[0.125 0.5 ]\n", + " [0.625 0.875]]\n", + "Tile 742: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 746: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 748: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 749: Predicted: [[0.23046191 0.251767 ]\n", + " [0.13268414 0.5215669 ]], True: [[0. 0.625]\n", + " [0.375 0.125]]\n", + "Tile 750: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 751: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[0.00482875 0.00561155]\n", + " [0.00635518 0.5790131 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 753: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 754: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 756: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 760: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 764: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 765: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 766: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 768: Predicted: [[ 0.0019069 -0.00442257]\n", + " [ 0.21657439 0.31775266]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 771: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 777: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 778: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 779: Predicted: [[0.01356518 0.02346966]\n", + " [0.0210807 0.6515313 ]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 780: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 781: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[0.00116433 0.00108467]\n", + " [0.00097913 0.00175549]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 786: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 788: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 789: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 790: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 792: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 793: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 795: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 796: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 797: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 798: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 799: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[ 0.00366084 -0.00426495]\n", + " [ 0.492905 0.00995742]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 801: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 802: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[0.00517601 0.0021932 ]\n", + " [0.10365636 0.3879488 ]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 805: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 806: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 807: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 808: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 809: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 819: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 820: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 823: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 824: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 825: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 829: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 830: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 832: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 836: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 838: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 839: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 840: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 841: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 843: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 844: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[ 0.00360926 -0.00352565]\n", + " [ 0.5064403 0.7372867 ]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 847: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 850: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[0.43921316 0.2909629 ]\n", + " [0.8415704 0.7242024 ]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 853: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 854: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 857: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 858: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 860: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 861: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[0.0079543 0.00734799]\n", + " [0.492953 0.62919605]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 866: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[0.01687824 0.00697868]\n", + " [0.2634287 0.0652981 ]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 868: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[0.00469089 0.00392372]\n", + " [0.499004 0.09296127]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 874: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 875: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 876: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 878: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 879: Predicted: [[0.01212412 0.00667822]\n", + " [0.4800873 0.75169176]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 880: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 883: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[-0.00095935 0.00072158]\n", + " [ 0.5268631 0.0097061 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 885: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 886: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 887: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 888: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 889: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 894: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 895: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 896: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 901: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 904: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 909: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 912: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 917: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 918: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 919: Predicted: [[-0.0015052 0.00407736]\n", + " [ 0.64082503 0.25017926]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 920: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 921: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 922: Predicted: [[0.00110591 0.00234821]\n", + " [0.44132394 0.12620129]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 923: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 924: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 928: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[0.00746091 0.02028577]\n", + " [0.05872969 0.36549547]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 930: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 935: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 937: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 938: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 941: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 942: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[0.00186183 0.00127244]\n", + " [0.00029671 0.0001543 ]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 944: Predicted: [[0.00097834 0.00144016]\n", + " [0.00174844 0.23698494]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 948: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 949: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 951: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 953: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 954: Predicted: [[0.01250541 0.00618742]\n", + " [0.2488668 0.6586227 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[-0.00071637 -0.00350095]\n", + " [ 0.6635697 0.47387636]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 956: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 957: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 959: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 962: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 964: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 965: Predicted: [[0.01281567 0.00425798]\n", + " [0.48134434 0.7417266 ]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 966: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 967: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 969: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 970: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 974: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 976: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 978: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 979: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 980: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 982: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 984: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[-1.5884583e-03 8.1838807e-04]\n", + " [ 1.1602296e-01 -7.4741431e-05]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 987: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 988: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 992: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 995: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 996: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1001: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1002: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1004: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1005: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1006: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1008: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1009: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1012: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1014: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1015: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1016: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1017: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1019: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1020: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1021: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1022: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1023: Predicted: [[0.00124988 0.00101115]\n", + " [0.00072618 0.00048444]], True: [[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "image_index = np.random.randint(0, 8) # Randomly pick an image in the batch\n", + "# image_index = 0\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize counters for recomputed statistics\n", + "zero_hit_correct = 0\n", + "zero_hit_total = 0\n", + "\n", + "one_hit_correct = 0\n", + "one_hit_total = 0\n", + "\n", + "two_hit_correct = 0\n", + "two_hit_total = 0\n", + "\n", + "# Error accumulators\n", + "zero_hit_errors = []\n", + "one_hit_errors = []\n", + "two_hit_errors = []\n", + "\n", + "# Recompute metrics with direct comparison to ground truth\n", + "for i in range(predicted_centers.shape[0]): # Batch size\n", + " for j in range(predicted_centers.shape[1]): # Tiles per image\n", + " # True and predicted hits for the current tile\n", + " true_hits = grouped_targets[i, j]\n", + " pred_hits = predicted_centers[i, j]\n", + "\n", + " # Count non-zero hits\n", + " true_nonzero = np.any(true_hits != 0, axis=-1)\n", + " num_true_hits = np.sum(true_nonzero)\n", + "\n", + " # Case: 0 hits\n", + " if num_true_hits == 0:\n", + " zero_hit_total += 1\n", + " if np.allclose(pred_hits, 0, atol=0.1): # Predictions close to (0, 0)\n", + " zero_hit_correct += 1\n", + " zero_hit_errors.append(np.linalg.norm(pred_hits))\n", + "\n", + " # Case: 1 hit\n", + " elif num_true_hits == 1:\n", + " one_hit_total += 1\n", + " true_hit = true_hits[true_nonzero][0]\n", + " pred_distances = np.linalg.norm(pred_hits - true_hit, axis=-1)\n", + " closest_pred = np.argmin(pred_distances)\n", + "\n", + " if pred_distances[closest_pred] < 0.1: # Correct if close enough\n", + " one_hit_correct += 1\n", + "\n", + " one_hit_errors.append(pred_distances[closest_pred])\n", + "\n", + " # Case: 2 hits\n", + " elif num_true_hits == 2:\n", + " two_hit_total += 1\n", + " dist_1 = np.linalg.norm(true_hits[0] - pred_hits[0]) + np.linalg.norm(true_hits[1] - pred_hits[1])\n", + " dist_2 = np.linalg.norm(true_hits[0] - pred_hits[1]) + np.linalg.norm(true_hits[1] - pred_hits[0])\n", + "\n", + " error = min(dist_1, dist_2)\n", + " if error < 0.1: # Correct if permutation invariant\n", + " two_hit_correct += 1\n", + "\n", + " two_hit_errors.append(error)\n", + "\n", + "# Compute accuracy for each case\n", + "zero_hit_accuracy = zero_hit_correct / zero_hit_total if zero_hit_total > 0 else 0\n", + "one_hit_accuracy = one_hit_correct / one_hit_total if one_hit_total > 0 else 0\n", + "two_hit_accuracy = two_hit_correct / two_hit_total if two_hit_total > 0 else 0\n", + "\n", + "# Compute average error for each case\n", + "avg_zero_hit_error = np.mean(zero_hit_errors) if zero_hit_errors else 0\n", + "avg_one_hit_error = np.mean(one_hit_errors) if one_hit_errors else 0\n", + "avg_two_hit_error = np.mean(two_hit_errors) if two_hit_errors else 0\n", + "\n", + "# Visualization of recomputed statistics\n", + "labels = ['0 Hits', '1 Hit', '2 Hits']\n", + "accuracies = [zero_hit_accuracy, one_hit_accuracy, two_hit_accuracy]\n", + "avg_errors = [avg_zero_hit_error, avg_one_hit_error, avg_two_hit_error]\n", + "\n", + "# Plot recomputed accuracy\n", + "plt.figure(figsize=(12, 6))\n", + "plt.bar(labels, accuracies, alpha=0.7, color='blue', edgecolor='black')\n", + "plt.title(\"Recomputed Prediction Accuracy by Case\", fontsize=14)\n", + "plt.ylabel(\"Accuracy\", fontsize=12)\n", + "plt.xlabel(\"Case\", fontsize=12)\n", + "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + "plt.show()\n", + "\n", + "# Plot recomputed average error\n", + "plt.figure(figsize=(12, 6))\n", + "plt.bar(labels, avg_errors, alpha=0.7, color='orange', edgecolor='black')\n", + "plt.title(\"Recomputed Average Error by Case\", fontsize=14)\n", + "plt.ylabel(\"Average Error (Distance)\", fontsize=12)\n", + "plt.xlabel(\"Case\", fontsize=12)\n", + "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Case Average Pixel Offset\n", + "0 0 Hits 0.008693\n", + "1 1 Hit 0.133286\n", + "2 2 Hits 0.440628\n" + ] + } + ], + "source": [ + "# Compute pixel-level error for each case\n", + "avg_pixel_error_zero_hit = np.mean(zero_hit_errors) if zero_hit_errors else 0\n", + "avg_pixel_error_one_hit = np.mean(one_hit_errors) if one_hit_errors else 0\n", + "avg_pixel_error_two_hit = np.mean(two_hit_errors) if two_hit_errors else 0\n", + "\n", + "# Summarize the results\n", + "pixel_error_summary = {\n", + " \"0 Hits\": avg_pixel_error_zero_hit,\n", + " \"1 Hit\": avg_pixel_error_one_hit,\n", + " \"2 Hits\": avg_pixel_error_two_hit,\n", + "}\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create a DataFrame to display the summary\n", + "error_df = pd.DataFrame.from_dict(\n", + " pixel_error_summary, orient='index', columns=[\"Average Pixel Offset\"]\n", + ")\n", + "error_df.index.name = \"Case\"\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create a DataFrame for better visualization\n", + "pixel_error_summary = {\n", + " \"Case\": [\"0 Hits\", \"1 Hit\", \"2 Hits\"],\n", + " \"Average Pixel Offset\": [avg_pixel_error_zero_hit, avg_pixel_error_one_hit, avg_pixel_error_two_hit]\n", + "}\n", + "\n", + "# Convert to a pandas DataFrame\n", + "error_df = pd.DataFrame(pixel_error_summary)\n", + "\n", + "# Print the DataFrame\n", + "print(error_df)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution of hits across all tiles:\n", + "0 hits: 92999\n", + "1 hits: 8963\n", + "2 hits: 438\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# After you load and normalize the data\n", + "normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# Flatten to tile-level\n", + "num_images = normalized_centers.shape[0] # how many big images\n", + "num_tiles = normalized_centers.shape[1] # tiles per image, e.g. 256*256 / (8*8) = 1024\n", + "max_hits = normalized_centers.shape[2] # 2\n", + "_ = normalized_centers.shape[3] # 2 coords\n", + "\n", + "num_hits_distribution = {0: 0, 1: 0, 2: 0}\n", + "\n", + "for i in range(num_images):\n", + " for t in range(num_tiles):\n", + " # Extract the 2 hits for tile t of image i\n", + " tile_hits = normalized_centers[i, t] # shape (2,2)\n", + " # Determine how many are nonzero\n", + " row_nonzero = np.any(tile_hits != 0, axis=-1) # shape (2,)\n", + " hits_count = np.sum(row_nonzero) # 0,1, or 2\n", + " num_hits_distribution[hits_count] += 1\n", + "\n", + "print(\"Distribution of hits across all tiles:\")\n", + "for k in [0,1,2]:\n", + " print(f\"{k} hits: {num_hits_distribution[k]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 96\n", + "False Positives (FP): 5\n", + "False Negatives (FN): 1\n", + "Precision: 0.9505, Recall: 0.9897\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "\n", + "threshold = 0.8 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits): \n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1* tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 99\n", + "False Positives (FP): 0\n", + "False Negatives (FN): 0\n", + "Precision: 1.0000, Recall: 1.0000\n" + ] + } + ], + "source": [ + "\n", + "\n", + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.8\n", + "tile_size = 8\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " matched_true_hits = set()\n", + " matched_predictions = set()\n", + "\n", + " for pred_idx, pred in enumerate(valid_predicted_hits):\n", + " if pred_idx in matched_predictions:\n", + " continue\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1 *tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " matched_predictions.add(pred_idx)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage\n", + "tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# Plotting\n", + "fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "for i in range(4):\n", + " ax[i].imshow(tiles[i], cmap='gray')\n", + " ax[i].set_title(f\"Tile {i}\")\n", + " ax[i].axis('off')\n", + "\n", + "ax[4].imshow(reconstructed_image, cmap='gray')\n", + "ax[4].set_title(\"Reconstructed Image\")\n", + "ax[4].axis('off')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.2):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "c = np.random.randint(0,8)\n", + "image_index = c # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First image's first tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n", + "First image's second tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "for val_images, val_centers in val_dataset.take(1):\n", + " print(\"First image's first tile:\")\n", + " print(val_images[2, 0]) # Tile 0 of Image 0\n", + " print(\"First image's second tile:\")\n", + " print(val_images[2, 1]) # Tile 1 of Image 0\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/Object_Detection.ipynb b/Computer Vision_Object Detection/Object_Detection.ipynb new file mode 100644 index 0000000..7ad2046 --- /dev/null +++ b/Computer Vision_Object Detection/Object_Detection.ipynb @@ -0,0 +1,22 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/ReadME.md b/Computer Vision_Object Detection/ReadME.md new file mode 100644 index 0000000..b066463 --- /dev/null +++ b/Computer Vision_Object Detection/ReadME.md @@ -0,0 +1,154 @@ +For Data Generation +**1.1** +Create a blank canvas (2D array of zeros) with a predefined size, I used 256 by 256. The canvas acts as the background for placing the hits so it will be filled with zeroes initially. + + +**1.2** +Use a collection of preloaded small images(the frames containing the electron hits) representing "electron hits." +From here on out, I will use frames to represent these small images. +Extract the dimensions (height, width) of these images. Assume all hits have uniform dimensions. For the frames in the 200kV_98000electron.tif file, they are 19 by 19 pixels each. + + +**1.3.1** +Randomly generate a top-left coordinate (x, y) for the placement on the canvas: +I created a fictitious canvas which overlays the original canvas I want to put the frames on. I will later explain why the fictitious canvas shouldn’t perfectly align with the original canvas. + +The goal is to find random top-left corner coordinates (x,y) on the canvas where the frame can be placed. This placement must ensure that the entire frame fits within the canvas without going outside the boundaries. I define the random (x,y) with the lines below. + +x = random.randint(1 - width//2, max_x - width//2 - 1), y = random.randint(1 - height//2, max_y - height//2 - 1) +Width and Height will be that for the frame so 19 in this case. Max_x and Max_y will be that for the original canvas. + +So the range for the fictitious canvas will be +1 - 19//2 to 256 - 19//2 - 1 +1 - 9 to 256 - 9 - 1 +-8 to 246 for the x and I repeat the same for y. + +I then randomly select a frame from the 200kV_98000electron.tif file and randomly(according to the range calculated) place them on the fictitious canvas and an ‘image’ will be created. Now this ‘image’ will have the fictitious canvas and the original canvas. + + +**1.3.2** +Ensure coordinates account for potential cropping at the edges: +The center of the frame is calculated based on its top-left corner (x, y) and its dimensions (width, height). I just offset the top-left corner by approximately half of the width and height. +x_center = x + width // 2 —// is floor division. +y_center = y + height // 2 + +Suppose x = 10 and y = 20 from my edge case(I mean the top-left corner random picking), +x_center = 10 + 19 // 2 = 10 + 9 = 19. +y_center = 20 + 19 // 2 = 20 + 9 = 29. +So the exact position will be the (19,29) on the original canvas. The ‘image’ is then clipped to retain the original canvas size. + +The coordinates for each image are stored with the image as tuples. + + +**1.4** +Create a function to generate multiple images and store the images and centers as h5 datasets. + + + + + + +For Training +2. --Data Preparation +__Initialize Data Loader:__ +Use the DataLoader class to load data from an HDF5 file containing: +images: A collection of 2D arrays representing electron hit images. +centers_training: The hit coordinates in each image. +__Load Data:__ +Use the load_data method to extract the images and centers arrays from the file. + +__Tile Images:__ +Divide each image into smaller square tiles of size tile_size using the tile_image method. +Ensure tiles are non-overlapping and of uniform size. + +__Map Hits to Tiles:__ +Let’s say I pick one 256x256 image + +Tile size: 8x8 pixels. This divides the image into 1024 tiles (32 rows × 32 columns) with each tile having a unique index. +Hit centers: Assume there are only 3 hits with the following coordinates: centers = [(1, 2), (10, 5), (14, 14)] +For each hit (x1, y1), we determine the tile it belongs to and its local coordinates within the tile. + +Hit 1: (1, 2) + +Tile Row and Column: + +Tile row = y // tile_size = 2 // 8 = 0. +Tile column = x // tile_size = 1 // 8 = 0. +tile_index = tile_row * (image_width // tile_size) + tile_col = 0 * (256 // 8) + 0 = 0 + + +Local Coordinates: + +Local x = x % tile_size = 1 % 8 = 1. +Local y = y % tile_size = 2 % 8 = 2. + +The local coordinates are for the tiles and the ‘global’ coordinates are for the giant(256x256) original image. +I repeat the same for all the other hits and store that in a dictionary for each tile index. + +Tile Indices: Calculated based on the hit's position relative to the overall image. +Local Coordinates: Allow precise positioning within a specific tile. +Empty Tiles: If no hits fall in a tile, its list of hits will be empty. + +__Process Data__ +Pad tiles with dummy hits (0, 0) to ensure uniformity up to max_hits_per_tile(I used 2 in my case). + +__Normalize Data__ +Scale pixel intensities to the range [0, 1]. +Normalize hit coordinates to be relative to the tile dimensions (range [0, 1]). + +__Create Datasets__ +Split normalized data into training and validation sets using train_test_split. +Use TensorFlow’s Dataset API to create batched datasets for: +Training (train_dataset) and Validation (val_dataset). + +NB: Tiles may get mixed up if shuffled across images and reconstruction becomes complex if not difficult. + + + +3. Call class to load data +""" + +file_path = '/path/to/h5/file' + +data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2) +images, centers = data_loader.load_data() + +train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)""" + +4. Define a function to visualise the tiles and their corresponding centers/labels for verification. + +5. Neural Network input shape should be (tile_size,tile_size,number of channels) and the classes should be max_number_of_hits_per_tile as the tiles are treated as individual images for the Neural Network. + Model hyperparameters include: + batch size = 500 + optimizer = Adam + loss function = Mean Squared Error. if the number of hits per tile are more than 2, it is recommended to use a matching algorithm. + learning rate = 0.001 (use lr scheduler with the following arguments:- monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6) + + +6. Training was done on 2 gpus(A100) which took appoximately 37 mins for 50 epochs. + +7. +8. + +9. __Model Performance Assessment__ + For each tile in the predictions: + compare the predictions to the top left corner of the tile and if it the prediction is not equal to the top left corner, it is a valid prediction.This is done to ignore the padding.Next this coordinate should be greater or .1 pixel relative to the top left corner of the tile.This is a valid predicted hit. Valid doesn't mean True or accurate.This is also done to ignore predictions for paddings that were not neccessarily (0,0) but were close to (0,0). + For each tile in the groundtruth: + compare the coordinates to the top left corner of the tile and if the coordinate is greater than the top left corner, it is a valid groundtruth. + + For the filtered predictions: + find the euclidean distance between the groundtruth and the prediction and compare that to a preset pixel distance. If the eucliean distance within the preset pixel distance(denormalize with tile size or how coordinates were normalized), the prediction is a True Positive. If all the groundtruths in the tile have a matched hit and a prediction is without a matched truth, the unmatched prediction is considered a False Positive. + +10. __For reconstruction of original image:__ + Create a an empty canvas. + since the images used were square images, the number of tiles per row is just the squareroot of the total number of tiles per image. + Pick an index in the tiles for an image: + for the row on which the tile goes, do a floor division of the index with the number of tiles per row. + for the column on which the tile goes, do a modulo computation of the index with the number of tiles per row. + On the empty canvas,place these tiles according to the row and column numbers and use a stride of the tile size. + + + + + + diff --git a/Computer Vision_Object Detection/Selecting 1 hits more.ipynb b/Computer Vision_Object Detection/Selecting 1 hits more.ipynb new file mode 100644 index 0000000..9261469 --- /dev/null +++ b/Computer Vision_Object Detection/Selecting 1 hits more.ipynb @@ -0,0 +1,5836 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:11:10.614073: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-22 15:11:10.629573: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-22 15:11:10.643090: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-22 15:11:10.647230: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-22 15:11:10.659541: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-22 15:11:11.256374: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:4',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:11:12.201165: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:4f:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"4\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:4\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:1000])\n", + " centers = np.array(f['centers_training'][:1000])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def split_by_hit_count(centers):\n", + " \"\"\"\n", + " Split tiles into 0-hit, 1-hit, and 2-hit groups based on the ground truth centers.\n", + "\n", + " Args:\n", + " - centers: (num_tiles, max_hits_per_tile, 2), normalized ground truth centers.\n", + "\n", + " Returns:\n", + " - groups: A dictionary with keys `0-hit`, `1-hit`, and `2-hit` containing tile indices.\n", + " \"\"\"\n", + " # Check if hits are non-zero\n", + " hit_mask = tf.reduce_any(tf.not_equal(centers, 0.0), axis=-1) # (num_tiles, max_hits_per_tile)\n", + " hit_counts = tf.reduce_sum(tf.cast(hit_mask, tf.int32), axis=-1) # (num_tiles,)\n", + " \n", + " # Separate into groups\n", + " groups = {\n", + " '0-hit': tf.where(hit_counts == 0)[:, 0].numpy(), # Indices for 0-hit tiles\n", + " '1-hit': tf.where(hit_counts == 1)[:, 0].numpy(), # Indices for 1-hit tiles\n", + " '2-hit': tf.where(hit_counts == 2)[:, 0].numpy(), # Indices for 2-hit tiles\n", + " }\n", + " return groups\n", + "\n", + "def create_custom_batches_with_zeros(images, centers, batch_size, tile_size, max_hits_per_tile, one_hit_ratio, two_hit_ratio):\n", + " groups = split_by_hit_count(centers)\n", + "\n", + " zero_hit_tiles = groups['0-hit']\n", + " one_hit_tiles = groups['1-hit']\n", + " two_hit_tiles = groups['2-hit']\n", + "\n", + " # Shuffle the indices\n", + " np.random.shuffle(zero_hit_tiles)\n", + " np.random.shuffle(one_hit_tiles)\n", + " np.random.shuffle(two_hit_tiles)\n", + "\n", + " one_hit_count = int(batch_size * one_hit_ratio)\n", + " two_hit_count = int(batch_size * two_hit_ratio)\n", + " zero_hit_count = batch_size - one_hit_count - two_hit_count\n", + "\n", + " def generator():\n", + " while True:\n", + " # Adjust counts dynamically if the group size is smaller\n", + " actual_one_hit_count = min(len(one_hit_tiles), one_hit_count)\n", + " actual_two_hit_count = min(len(two_hit_tiles), two_hit_count)\n", + " actual_zero_hit_count = min(len(zero_hit_tiles), zero_hit_count)\n", + "\n", + " if actual_one_hit_count > 0:\n", + " batch_one_hit = np.random.choice(one_hit_tiles, actual_one_hit_count, replace=False)\n", + " else:\n", + " batch_one_hit = []\n", + "\n", + " if actual_two_hit_count > 0:\n", + " batch_two_hit = np.random.choice(two_hit_tiles, actual_two_hit_count, replace=False)\n", + " else:\n", + " batch_two_hit = []\n", + "\n", + " if actual_zero_hit_count > 0:\n", + " batch_zero_hit = np.random.choice(zero_hit_tiles, actual_zero_hit_count, replace=False)\n", + " else:\n", + " batch_zero_hit = []\n", + "\n", + " # Combine batches\n", + " batch_indices = np.concatenate([batch_one_hit, batch_two_hit, batch_zero_hit])\n", + "\n", + " # Shuffle the final batch\n", + " np.random.shuffle(batch_indices)\n", + "\n", + " # Yield the data\n", + " yield images[batch_indices], centers[batch_indices]\n", + "\n", + " dataset = tf.data.Dataset.from_generator(\n", + " generator,\n", + " output_signature=(\n", + " tf.TensorSpec(shape=(batch_size, tile_size, tile_size, 1), dtype=tf.float32),\n", + " tf.TensorSpec(shape=(batch_size, max_hits_per_tile, 2), dtype=tf.float32)\n", + " )\n", + " ).prefetch(tf.data.AUTOTUNE)\n", + "\n", + " return dataset\n", + "\n", + "\n", + "\n", + "\n", + "def create_datasets(data_loader, train_size=0.95, batch_size=1024, one_hit_ratio=0.7, two_hit_ratio=0.2):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, data_loader.tile_size, data_loader.tile_size, 1)\n", + " val_images_flat = val_images.reshape(-1, data_loader.tile_size, data_loader.tile_size, 1)\n", + "\n", + " # Flatten centers to match tiles\n", + " train_centers_flat = train_centers.reshape(-1, data_loader.max_hits_per_tile, 2)\n", + " val_centers_flat = val_centers.reshape(-1, data_loader.max_hits_per_tile, 2)\n", + "\n", + " # Create custom train dataset\n", + " train_dataset = create_custom_batches_with_zeros(\n", + " train_images_flat,\n", + " train_centers_flat,\n", + " batch_size,\n", + " data_loader.tile_size,\n", + " data_loader.max_hits_per_tile,\n", + " one_hit_ratio=one_hit_ratio,\n", + " two_hit_ratio=two_hit_ratio\n", + " )\n", + "\n", + " # Validation dataset without special sampling\n", + " val_dataset = tf.data.Dataset.from_tensor_slices(\n", + " (val_images_flat, val_centers_flat)\n", + " ).batch(batch_size).cache().prefetch(tf.data.AUTOTUNE)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# ---------- Example Usage ----------\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/20KFixed_10_256by256_RandomindexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(\n", + " data_loader, batch_size=2048, one_hit_ratio=0.9, two_hit_ratio=0.05\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1000, 200, 3)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # File path and data loading\n", + "# file_path = '/home/da886/Computer Vision_Object Detection/Data/10KFixed_100_256by256_RandomindexNoNoise.h5'\n", + "\n", + "# data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "# images, centers = data_loader.load_data()\n", + "# # Create datasets\n", + "# train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution of hits across all tiles:\n", + "0 hits: 844832\n", + "1 hits: 162427\n", + "2 hits: 16741\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# After you load and normalize the data\n", + "normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# Flatten to tile-level\n", + "num_images = normalized_centers.shape[0] # how many big images\n", + "num_tiles = normalized_centers.shape[1] # tiles per image, e.g. 256*256 / (8*8) = 1024\n", + "max_hits = normalized_centers.shape[2] # 2\n", + "_ = normalized_centers.shape[3] # 2 coords\n", + "\n", + "num_hits_distribution = {0: 0, 1: 0, 2: 0}\n", + "\n", + "for i in range(num_images):\n", + " for t in range(num_tiles):\n", + " # Extract the 2 hits for tile t of image i\n", + " tile_hits = normalized_centers[i, t] # shape (2,2)\n", + " # Determine how many are nonzero\n", + " row_nonzero = np.any(tile_hits != 0, axis=-1) # shape (2,)\n", + " hits_count = np.sum(row_nonzero) # 0,1, or 2\n", + " num_hits_distribution[hits_count] += 1\n", + "\n", + "print(\"Distribution of hits across all tiles:\")\n", + "for k in [0,1,2]:\n", + " print(f\"{k} hits: {num_hits_distribution[k]}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution of hits in the current batch:\n", + "0 hits: 103 tiles\n", + "1 hits: 1843 tiles\n", + "2 hits: 102 tiles\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:12:26.841709: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" + ] + } + ], + "source": [ + "# Get a single batch from the train_dataset\n", + "for train_batch_images, train_batch_centers in train_dataset.take(1): # Take one batch\n", + " # Initialize a dictionary to count hits\n", + " batch_hits_distribution = {0: 0, 1: 0, 2: 0}\n", + " \n", + " # Iterate through the batch\n", + " for tile_hits in train_batch_centers.numpy(): # Convert to NumPy for easier manipulation\n", + " # Determine how many hits are nonzero in the tile\n", + " row_nonzero = np.any(tile_hits != 0, axis=-1) # (max_hits_per_tile,)\n", + " hits_count = np.sum(row_nonzero) # 0, 1, or 2\n", + " batch_hits_distribution[hits_count] += 1\n", + "\n", + " # Print the distribution of hits in the batch\n", + " print(\"Distribution of hits in the current batch:\")\n", + " for k in [0, 1, 2]:\n", + " print(f\"{k} hits: {batch_hits_distribution[k]} tiles\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " \"\"\"\n", + " Create a model that predicts hit locations for individual tiles.\n", + " \n", + " Parameters:\n", + " - input_shape: shape of the input tile (e.g., (8, 8, 1)).\n", + " - max_hits: maximum number of hits per tile (e.g., 2).\n", + "\n", + " Returns:\n", + " - model: The Keras model.\n", + " \"\"\"\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional and pooling layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + "\n", + " # Final dense layer for predictions\n", + " outputs = layers.Dense(max_hits * 2,activation='linear')(x)\n", + "\n", + " # Reshape output to match the target structure per tile\n", + " outputs = layers.Reshape((max_hits, 2))(outputs)\n", + "\n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((8000, 1024, 8, 8),\n", + " (2000, 1024, 8, 8),\n", + " (8000, 1024, 2, 3),\n", + " (2000, 1024, 2, 3))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# train_outputs = model.predict(train_images[1])\n", + "# # val_outputs = model.predict(val_images[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(8000, 1024, 8, 8)" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# loss=tf.keras.losses.MeanSquaredError()\n", + "# tl =loss(train_outputs[827],train_centers[1][827])\n", + "# # vl = loss(val_outputs,val_centers[1])\n", + "# tl2 =masked_mse_excluding_zeros(train_outputs[827],train_centers[1][827])\n", + "# tl,tl2" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def hungarian_loss_for_two_hits_vectorized(y_true, y_pred):\n", + " \"\"\"\n", + " Permutation-invariant loss for a tile with up to 2 hits, vectorized version.\n", + " \n", + " y_true, y_pred: (batch_size, 2, 2)\n", + " - y_true[i] has up to 2 hits, with zero-padding for empty slots.\n", + " - y_pred[i] is the model's 2 predicted points.\n", + " Returns: scalar (averaged loss across the batch).\n", + " \"\"\"\n", + "\n", + " # 1) Identify how many hits per tile\n", + " # row_nonzero[i,j] = True if y_true[i,j] != (0,0)\n", + " row_nonzero = tf.reduce_any(tf.not_equal(y_true, 0.0), axis=-1) # (batch_size, 2)\n", + " num_hits = tf.reduce_sum(tf.cast(row_nonzero, tf.float32), axis=-1) # (batch_size,), values ∈ {0,1,2}\n", + "\n", + " # 2) Create masks for 0-hit, 1-hit, 2-hit tiles\n", + " mask_0 = tf.equal(num_hits, 0.0) # (batch_size,)\n", + " mask_1 = tf.equal(num_hits, 1.0) # (batch_size,)\n", + " mask_2 = tf.equal(num_hits, 2.0) # (batch_size,)\n", + "\n", + " mask_0_f = tf.cast(mask_0, tf.float32)\n", + " mask_1_f = tf.cast(mask_1, tf.float32)\n", + " mask_2_f = tf.cast(mask_2, tf.float32)\n", + "\n", + " # -------------------------------------------------------------------------\n", + " # CASE 0 HITS: Force both predicted points to be (0,0).\n", + " # -------------------------------------------------------------------------\n", + " # cost0[i] = sum of squares of y_pred[i], i.e. (pred1^2 + pred2^2)\n", + " cost0 = tf.reduce_sum(tf.square(y_pred), axis=[1, 2]) # (batch_size,)\n", + "\n", + " # -------------------------------------------------------------------------\n", + " # CASE 2 HITS: Permutation-invariant cost.\n", + " # -------------------------------------------------------------------------\n", + " # cost_1 corresponds to (hit1→pred1, hit2→pred2)\n", + " dist_1_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 0, :]), axis=-1)\n", + " dist_1_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 1, :]), axis=-1)\n", + " cost_1 = dist_1_1 + dist_1_2\n", + "\n", + " # cost_2 corresponds to (hit1→pred2, hit2→pred1)\n", + " dist_2_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 1, :]), axis=-1)\n", + " dist_2_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 0, :]), axis=-1)\n", + " cost_2 = dist_2_1 + dist_2_2\n", + "\n", + " # Pick the smaller permutation cost\n", + " cost2 = tf.minimum(cost_1, cost_2) # (batch_size,)\n", + "\n", + " # -------------------------------------------------------------------------\n", + " # CASE 1 HIT:\n", + " # - Identify which row is the real hit (row0 or row1).\n", + " # - Compute MSE for matching that hit to whichever predicted row is closer.\n", + " # - Penalize the other predicted row for not being (0,0).\n", + " # -------------------------------------------------------------------------\n", + " row0_is_hit = row_nonzero[:, 0] # (batch_size,)\n", + " # ground-truth single hit => either tile_true[:,0,:] or tile_true[:,1,:]\n", + " gt_hit = tf.where(\n", + " tf.expand_dims(row0_is_hit, axis=-1),\n", + " y_true[:, 0, :],\n", + " y_true[:, 1, :]\n", + " ) # (batch_size, 2)\n", + "\n", + " # Distances to each predicted point\n", + " dist_pred_0 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 0, :]), axis=-1)\n", + " dist_pred_1 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 1, :]), axis=-1)\n", + "\n", + " # Also penalize the other row for not being near (0,0).\n", + " zero_cost_0 = tf.reduce_sum(tf.square(y_pred[:, 0, :]), axis=-1)\n", + " zero_cost_1 = tf.reduce_sum(tf.square(y_pred[:, 1, :]), axis=-1)\n", + "\n", + " # Two ways to match:\n", + " # -- pred_0 is the real hit => dist_pred_0 + zero_cost_1\n", + " # -- pred_1 is the real hit => dist_pred_1 + zero_cost_0\n", + " cost_if_0_matched = dist_pred_0 + zero_cost_1\n", + " cost_if_1_matched = dist_pred_1 + zero_cost_0\n", + " cost1 = tf.minimum(cost_if_0_matched, cost_if_1_matched) # (batch_size,)\n", + "\n", + " # -------------------------------------------------------------------------\n", + " # Combine costs across all tiles\n", + " # For each tile i, only one of mask_0, mask_1, mask_2 is True.\n", + " # -------------------------------------------------------------------------\n", + " total_cost = mask_0_f * cost0 + mask_1_f * cost1 + mask_2_f * cost2\n", + "\n", + " # Average over the batch\n", + " loss = tf.reduce_mean(total_cost)\n", + " return loss\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape (Reshape)               │ (None, 2, 2)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(optimizer = 'adam', loss= hungarian_loss_for_two_hits_vectorized)\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:12:47.535218: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "2025-01-22 15:12:48.462633: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1737576768.540529 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.582409 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.582774 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.587337 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.598393 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.599912 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.600640 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.601010 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.602577 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.613501 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.613853 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.614189 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.614550 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.614921 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.615312 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.616758 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.618234 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.619736 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.621413 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.623037 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.624953 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.625460 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.626761 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.633643 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.635087 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.706986 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.707323 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.707587 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.708096 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.708803 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.710091 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.710371 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.710632 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.710892 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.711157 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.711420 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.711698 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.712762 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.713344 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.714710 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.715001 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.715289 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.716496 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.716798 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.717081 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.717371 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.718524 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.718860 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.725412 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.725823 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.726143 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.726479 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.726953 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.727445 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.732077 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576768.734069 2657999 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 5/Unknown \u001b[1m2s\u001b[0m 15ms/step - loss: 0.5119" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737576769.111893 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.112418 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.112824 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.113277 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.114540 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.115637 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.117145 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.117665 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.119071 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.119674 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.120014 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.120314 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.122442 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.123890 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.124231 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.125696 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.127323 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.128892 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.130799 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.144087 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.145431 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.147309 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.147617 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.147931 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.148396 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.148773 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.149069 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.151158 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.151469 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.153472 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.155085 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.155387 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.155687 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.155979 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.156297 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.156653 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.156990 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.158346 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.159801 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.160115 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.165592 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.165920 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.166375 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.167710 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.169919 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.186515 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.191337 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.202092 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.202626 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.202979 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.203385 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.203780 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.204175 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.204563 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.205056 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.205490 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.205960 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.207014 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.208127 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.208806 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.209459 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737576769.210544 2658000 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 370891/Unknown \u001b[1m6454s\u001b[0m 17ms/step - loss: 0.0239" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[12], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mlr_scheduler\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/keras/src/utils/traceback_utils.py:117\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 115\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 117\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 118\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 119\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/keras/src/backend/tensorflow/trainer.py:318\u001b[0m, in \u001b[0;36mTensorFlowTrainer.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq)\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m step, iterator \u001b[38;5;129;01min\u001b[39;00m epoch_iterator\u001b[38;5;241m.\u001b[39menumerate_epoch():\n\u001b[1;32m 317\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m--> 318\u001b[0m logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 319\u001b[0m logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pythonify_logs(logs)\n\u001b[1;32m 320\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_end(step, logs)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:833\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 830\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 832\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 833\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 835\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 836\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:878\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 875\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[1;32m 876\u001b[0m \u001b[38;5;66;03m# In this case we have not created variables on the first call. So we can\u001b[39;00m\n\u001b[1;32m 877\u001b[0m \u001b[38;5;66;03m# run the first trace but we should fail if variables are created.\u001b[39;00m\n\u001b[0;32m--> 878\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 879\u001b[0m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_variable_creation_config\u001b[49m\n\u001b[1;32m 880\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 881\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_created_variables:\n\u001b[1;32m 882\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCreating variables on a non-first call to a function\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 883\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m decorated with tf.function.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[0;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[1;32m 137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[0;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[1;32m 140\u001b[0m \u001b[43m \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[1;32m 141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py:1322\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[1;32m 1318\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1319\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1320\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1321\u001b[0m \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1322\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1323\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1324\u001b[0m args,\n\u001b[1;32m 1325\u001b[0m possible_gradient_type,\n\u001b[1;32m 1326\u001b[0m executing_eagerly)\n\u001b[1;32m 1327\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m 214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m 215\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 216\u001b[0m flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 217\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[1;32m 250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[0;32m--> 251\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 252\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 253\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 254\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 256\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 257\u001b[0m outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[1;32m 258\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 259\u001b[0m \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[1;32m 260\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[1;32m 261\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/context.py:1552\u001b[0m, in \u001b[0;36mContext.call_function\u001b[0;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[1;32m 1550\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[1;32m 1551\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1552\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1553\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1554\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1555\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1556\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1557\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1558\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1559\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1560\u001b[0m outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 1561\u001b[0m name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m 1562\u001b[0m num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1566\u001b[0m cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[1;32m 1567\u001b[0m )\n", + "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/tensorflow/python/eager/execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 52\u001b[0m ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 53\u001b[0m tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=20,\n", + " callbacks=[lr_scheduler]\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/10KFixed_100_256by256_RandomindexNoNoise_linear_maskingoutemptytiles.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Electron Counting Tiling approach/Trained weights/200KFixed_100_256by256_first1500_mse and sigmoid_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted_centers shape: (4, 1024, 2, 2)\n", + "grouped_targets shape: (4, 1024, 2, 2)\n", + "mask shape: (4, 1024)\n", + "\n", + "Check image index 0\n", + "Tile 0: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n", + "Tile 4: True=[[0. 0.]\n", + " [0. 0.]], Pred=[[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 1) Fake data: Suppose we have 4 images in a batch (B=4),\n", + "# each with 8x8x1 as \"input images\"...\n", + "# ------------------------------------------------------------------\n", + "B = 4\n", + "train_images = np.random.rand(B, 8, 8, 1).astype(np.float32) \n", + "\n", + "# and each image has 1024 tiles of size 2x2 (just simulating).\n", + "# We'll also pretend half of them are zero to see the effect.\n", + "train_centers = np.random.rand(B, 1024, 2, 2).astype(np.float32)\n", + "train_centers[0, :100] = 0 # Make first 100 tiles be zero for 1st image\n", + "\n", + "# Convert to tf.data.Dataset (usually you'd have many more images)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_centers))\n", + "train_dataset = train_dataset.batch(B) # all in one batch\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 2) Next, get one batch and do a forward pass with your model\n", + "# For demonstration, we'll skip the model and create dummy outputs\n", + "# ------------------------------------------------------------------\n", + "inputs, targets = next(iter(train_dataset)) # shape: (4, 8, 8, 1) and (4, 1024, 2, 2)\n", + "\n", + "# Suppose your model output shape is (B, 1024*4) or (B, 1024, 2, 2)\n", + "# For demonstration, let's pretend we produce random predictions:\n", + "predicted_outputs = np.random.rand(B, 1024, 2, 2).astype(np.float32)\n", + "\n", + "# Flatten them to mimic \"model.predict(inputs)\" returning a flatten shape:\n", + "predicted_outputs_flat = predicted_outputs.reshape(B, 1024*4) \n", + "\n", + "# If your real model is something like:\n", + "# predicted_outputs_flat = model.predict(inputs)\n", + "# Then you'd do the same sort of reshaping below.\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 3) Reshape predictions and targets so they match: (B, 1024, 2, 2)\n", + "# ------------------------------------------------------------------\n", + "predicted_centers = predicted_outputs_flat.reshape(B, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(B, 1024, 2, 2)\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 4) Create a mask where the ground truth is entirely zero for a tile\n", + "# ------------------------------------------------------------------\n", + "mask = np.all(grouped_targets == 0, axis=(-2, -1)) # shape: (B, 1024)\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 5) Force predicted centers to zero where the ground truth is zero\n", + "# ------------------------------------------------------------------\n", + "predicted_centers[mask] = 0\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 6) Print shapes to confirm\n", + "# ------------------------------------------------------------------\n", + "print(\"predicted_centers shape:\", predicted_centers.shape) # (4, 1024, 2, 2)\n", + "print(\"grouped_targets shape: \", grouped_targets.shape) # (4, 1024, 2, 2)\n", + "print(\"mask shape: \", mask.shape) # (4, 1024)\n", + "\n", + "# ------------------------------------------------------------------\n", + "# 7) Inspect a specific image in the batch\n", + "# ------------------------------------------------------------------\n", + "image_index = 0\n", + "tiles_pred = predicted_centers[image_index]\n", + "tiles_true = grouped_targets[image_index]\n", + "\n", + "print(f\"\\nCheck image index {image_index}\")\n", + "for tile_idx, (pred_tile, true_tile) in enumerate(zip(tiles_pred, tiles_true)):\n", + " # Only print first few tiles to keep it short\n", + " if tile_idx < 5:\n", + " print(f\"Tile {tile_idx}: True={true_tile}, Pred={pred_tile}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1736810270.643511 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.643964 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.644580 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.644647 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.644740 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.645311 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.645528 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.645609 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.645796 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.646265 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.646280 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.646396 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.646796 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.646929 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.647057 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.647358 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.647557 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.647726 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.648007 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.648207 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.648416 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.648555 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.648890 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.649203 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.649273 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.649478 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.649823 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.649914 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.650064 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.650439 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.650505 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.650770 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.651108 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.651126 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.651286 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.651745 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.651859 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.651915 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.652300 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.652560 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.652654 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.652851 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.653209 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.653320 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.653530 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.653902 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.653946 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.654099 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.654578 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.654596 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.654738 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.655122 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.655164 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.655348 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.655744 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.655787 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.656014 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.656379 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.656430 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.656606 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.656975 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.657030 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.657279 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.657602 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.657666 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.657878 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.658205 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.658242 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.658847 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.658849 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.659003 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.659273 2580378 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.659635 2580410 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.659750 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1736810270.660233 2580418 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "2025-01-13 18:17:50.705424: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + } + ], + "source": [ + "# Extract a batch of inputs\n", + "inputs, targets = next(iter(train_dataset)) # Extract a batch\n", + "\n", + "# Make predictions\n", + "objectness_preds, bbox_preds = model.predict(inputs)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "targets['objectness_output'][:800]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m 1/32\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 134ms/step" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 18:18:55.320297: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m 1/32\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 134ms/step" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 18:19:00.146351: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-13 18:19:10.040210: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_2580041/1539559218.py\u001b[0m in \u001b[0;36m?\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Iterate through the dataset\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbatch_inputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtrain_dataset\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Get predictions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mobjectness_preds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbox_preds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_inputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Process predictions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mobjectness_labels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mobjectness_preds\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0;31m# To get the full stack trace, call:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 121\u001b[0m \u001b[0;31m# `keras.config.disable_traceback_filtering()`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 122\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 124\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, x, batch_size, verbose, steps, callbacks)\u001b[0m\n\u001b[1;32m 442\u001b[0m def predict(\n\u001b[1;32m 443\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"auto\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 444\u001b[0m ):\n\u001b[1;32m 445\u001b[0m \u001b[0;31m# Create an iterator that yields batches of input data.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 446\u001b[0;31m epoch_iterator = TFEpochIterator(\n\u001b[0m\u001b[1;32m 447\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 448\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 449\u001b[0m \u001b[0msteps_per_epoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msteps\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, distribute_strategy, *args, **kwargs)\u001b[0m\n\u001b[1;32m 627\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 628\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_distribute_strategy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdistribute_strategy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 629\u001b[0m \u001b[0mdataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_iterator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 630\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdistribute\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDistributedDataset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 631\u001b[0;31m dataset = self._distribute_strategy.experimental_distribute_dataset(\n\u001b[0m\u001b[1;32m 632\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 633\u001b[0m )\n\u001b[1;32m 634\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_distributed_dataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/distribute_lib.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, dataset, options)\u001b[0m\n\u001b[1;32m 1464\u001b[0m \"\"\"\n\u001b[1;32m 1465\u001b[0m distribution_strategy_input_api_counter.get_cell(\n\u001b[1;32m 1466\u001b[0m self.__class__.__name__, \"distribute_dataset\").increase_by(1)\n\u001b[1;32m 1467\u001b[0m \u001b[0;31m# pylint: enable=line-too-long\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1468\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_extended\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_experimental_distribute_dataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/mirrored_strategy.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, dataset, options)\u001b[0m\n\u001b[1;32m 588\u001b[0m \u001b[0;34m\"InputReplicationMode.PER_REPLICA \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 589\u001b[0m \u001b[0;34m\"is only supported in \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 590\u001b[0m \u001b[0;34m\"`distribute_datasets_from_function`.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 591\u001b[0m )\n\u001b[0;32m--> 592\u001b[0;31m return input_util.get_distributed_dataset(\n\u001b[0m\u001b[1;32m 593\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 594\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_input_workers_with_options\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 595\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_container_strategy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/input_util.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(dataset, input_workers, strategy, num_replicas_in_sync, input_context, options, build, replica_order)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0mReturns\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0mA\u001b[0m \u001b[0mdistributed\u001b[0m \u001b[0mdataset\u001b[0m \u001b[0minstance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \"\"\"\n\u001b[1;32m 64\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtf2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menabled\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m return input_lib.DistributedDataset(\n\u001b[0m\u001b[1;32m 66\u001b[0m \u001b[0minput_workers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 67\u001b[0m \u001b[0mstrategy\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/input_lib.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, input_workers, strategy, dataset, num_replicas_in_sync, input_context, components, element_spec, enable_get_next_as_optional, build, options, replica_order)\u001b[0m\n\u001b[1;32m 800\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdataset\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 801\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_original_dataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 802\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_built\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 803\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbuild\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 804\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 805\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 806\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mbuild\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 807\u001b[0m raise ValueError(\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/input_lib.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, dataset_to_replace)\u001b[0m\n\u001b[1;32m 830\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cardinality\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_cardinality\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 831\u001b[0m self._enable_get_next_as_optional = _enable_get_next_as_optional(\n\u001b[1;32m 832\u001b[0m self._strategy, dataset, self._cardinality)\n\u001b[1;32m 833\u001b[0m \u001b[0mdistribute_start_time_ns\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime_ns\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 834\u001b[0;31m self._create_cloned_datasets_from_dataset(dataset, self._input_context,\n\u001b[0m\u001b[1;32m 835\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_input_workers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 836\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_strategy\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 837\u001b[0m self._num_replicas_in_sync)\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/input_lib.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, dataset, input_context, input_workers, strategy, num_replicas_in_sync)\u001b[0m\n\u001b[1;32m 915\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mworker\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 916\u001b[0m \u001b[0mcloned_dataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreplicated_ds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mworker\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 917\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mrebatch_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 918\u001b[0m \u001b[0mcloned_dataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrebatch_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcloned_dataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 919\u001b[0;31m cloned_dataset = input_ops.auto_shard_dataset(\n\u001b[0m\u001b[1;32m 920\u001b[0m \u001b[0mcloned_dataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_workers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mworker_devices\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 921\u001b[0m num_replicas_in_sync)\n\u001b[1;32m 922\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cloned_datasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcloned_dataset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/input_ops.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(dataset, num_shards, index, num_replicas_in_sync)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata_types\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDatasetV1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m return distribute._AutoShardDatasetV1(dataset, num_shards, index,\n\u001b[1;32m 54\u001b[0m num_replicas_in_sync)\n\u001b[1;32m 55\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m return distribute._AutoShardDataset(dataset, num_shards, index,\n\u001b[0m\u001b[1;32m 57\u001b[0m num_replicas_in_sync)\n\u001b[1;32m 58\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/data/experimental/ops/distribute.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, input_dataset, num_workers, index, num_replicas)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput_dataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_workers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_replicas\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_input_dataset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput_dataset\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 72\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_element_spec\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput_dataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melement_spec\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 74\u001b[0;31m variant_tensor = ged_ops.auto_shard_dataset(\n\u001b[0m\u001b[1;32m 75\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_input_dataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_variant_tensor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[0mnum_workers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_workers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/ops/gen_experimental_dataset_ops.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(input_dataset, num_workers, index, output_types, output_shapes, auto_shard_policy, num_replicas, name)\u001b[0m\n\u001b[1;32m 338\u001b[0m \"output_shapes\", output_shapes, \"num_replicas\", num_replicas)\n\u001b[1;32m 339\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 340\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 341\u001b[0m \u001b[0m_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_from_not_ok_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 342\u001b[0;31m \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_FallbackException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 343\u001b[0m \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 344\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 345\u001b[0m return auto_shard_dataset_eager_fallback(\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "# Iterate through the dataset\n", + "for batch_inputs, _ in train_dataset:\n", + " # Get predictions\n", + " objectness_preds, bbox_preds = model.predict(batch_inputs)\n", + "\n", + " # Process predictions\n", + " objectness_labels = (objectness_preds > 0.5).astype(int)\n", + " detected_bboxes = bbox_preds[objectness_labels.squeeze() == 1]\n", + "\n", + " # Optional: visualize or save the predictions\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 0:\n", + "Tile 0: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[0.5086723 0.5998142 ]\n", + " [0.4477557 0.57114255]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 4: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 5: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 6: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 7: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[0.11531043 0.85943604]\n", + " [0.12291953 0.7838036 ]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 11: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 18: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 23: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 24: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 28: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 29: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 30: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 31: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 34: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 35: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 37: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 38: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 44: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 46: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 48: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 49: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 51: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[0.47769973 0.311481 ]\n", + " [0.47535104 0.27387244]], True: [[0.5 0.125]\n", + " [0.5 0.375]]\n", + "Tile 53: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 55: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 59: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 61: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 63: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 64: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 65: Predicted: [[0.1283117 0.5030032 ]\n", + " [0.14955504 0.52314186]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 66: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 67: Predicted: [[0.14913586 0.8451868 ]\n", + " [0.15871088 0.7797885 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 68: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 69: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 71: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[ 0.7421275 -0.00097016]\n", + " [ 0.6936983 0.1312811 ]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 73: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 76: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 77: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[0.8172693 0.44537997]\n", + " [0.76296735 0.4050163 ]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 80: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 85: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 86: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 87: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 88: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 90: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 91: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 92: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 93: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 95: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 96: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 98: Predicted: [[0.85165316 0.8363754 ]\n", + " [0.7643863 0.71000624]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 99: Predicted: [[0.16427155 0.03502765]\n", + " [0.32122275 0.23191743]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 100: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 102: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 103: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[0.6260581 0.11498173]\n", + " [0.6315816 0.1655975 ]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 106: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 108: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 111: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 112: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 113: Predicted: [[0.8425392 0.13826047]\n", + " [0.6833178 0.25511464]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 114: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 118: Predicted: [[0.40760404 0.4547821 ]\n", + " [0.41292736 0.49225944]], True: [[0.375 0.5 ]\n", + " [0.875 0. ]]\n", + "Tile 119: Predicted: [[0.42864257 0.7014116 ]\n", + " [0.36450785 0.7315353 ]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 120: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 122: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 124: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 126: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 127: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 129: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 131: Predicted: [[0.2614755 0.11881852]\n", + " [0.28504968 0.1202908 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 134: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 140: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 141: Predicted: [[ 0.0044874 0.52586895]\n", + " [-0.03523579 0.52729887]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 142: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 143: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 145: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 147: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 149: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[0.27134645 0.6835255 ]\n", + " [0.2743014 0.7269665 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 151: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 155: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[ 0.14924598 0.01035252]\n", + " [ 0.22631633 -0.01855353]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 160: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 161: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 162: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[0.8754419 0.11987901]\n", + " [0.83254695 0.14357455]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 164: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 165: Predicted: [[0.01040208 0.87008727]\n", + " [0.02463177 0.8860945 ]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 166: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 167: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[0.48227906 0.53787595]\n", + " [0.48720777 0.5145328 ]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 169: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 171: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 172: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 174: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[0.5003775 0.13205884]\n", + " [0.49082392 0.12218986]], True: [[0.5 0.125]\n", + " [0. 0. ]]\n", + "Tile 179: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 180: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 182: Predicted: [[0.19443369 0.23725104]\n", + " [0.16936201 0.2794725 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 184: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 186: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 188: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 190: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 192: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 194: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 196: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[0.8979387 0.9863211]\n", + " [1.0043914 0.6789664]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 198: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 199: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 201: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 202: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[0.74847037 0.2184341 ]\n", + " [0.7360238 0.14262216]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 205: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 206: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 207: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 210: Predicted: [[0.7496032 0.10303693]\n", + " [0.72053206 0.13570167]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 211: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 212: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 213: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 214: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 215: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 216: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 217: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 218: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 219: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 220: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 222: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 225: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 226: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 227: Predicted: [[0.37324303 0.7378174 ]\n", + " [0.32915446 0.68869555]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 228: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 230: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 231: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 234: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 236: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 237: Predicted: [[0.7427477 0.6536188 ]\n", + " [0.70435464 0.56247294]], True: [[0.75 0.625]\n", + " [0. 0. ]]\n", + "Tile 238: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 239: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 240: Predicted: [[0.35286248 0.7344464 ]\n", + " [0.43246478 0.71495426]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 241: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 242: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[0.3509599 0.12094407]\n", + " [0.34519434 0.15798269]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 244: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 245: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 246: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 247: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 249: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 253: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 254: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 255: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 257: Predicted: [[0.5156902 0.7652395 ]\n", + " [0.52064407 0.7326821 ]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 258: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 259: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 262: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[0.49230647 0.8562237 ]\n", + " [0.48229533 0.7728693 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 264: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 266: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 267: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 268: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[0.637992 0.00875145]\n", + " [0.537006 0.16102009]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 272: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 273: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 274: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 278: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 279: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 280: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 281: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 283: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 284: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 286: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 287: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 288: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 290: Predicted: [[0.8309418 0.8230123]\n", + " [0.7135884 0.6782721]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 291: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 292: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 293: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 294: Predicted: [[0.2996159 0.7399583 ]\n", + " [0.27168238 0.69812834]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 295: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 296: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 297: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 298: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 299: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 300: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 302: Predicted: [[0.5128839 0.5147142 ]\n", + " [0.5338753 0.49364263]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 303: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 304: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 305: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 307: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 309: Predicted: [[0.00678462 0.6329559 ]\n", + " [0.00497884 0.60108757]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 310: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 311: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 313: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 314: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 315: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 317: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 318: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 320: Predicted: [[0.11871929 0.21494216]\n", + " [0.14854048 0.23678514]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 321: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[0.1576202 0.2465711 ]\n", + " [0.17491108 0.2588857 ]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 325: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 328: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 330: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 333: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 334: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 336: Predicted: [[ 0.01042256 0.4480891 ]\n", + " [-0.04112223 0.43935382]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 337: Predicted: [[0.49836037 0.75753367]\n", + " [0.5583652 0.68497074]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 338: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 339: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 340: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 342: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 344: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 345: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 347: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 349: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 350: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 351: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 353: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 354: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 355: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 356: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 362: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 365: Predicted: [[0.3100459 0.32884055]\n", + " [0.29183996 0.31276503]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 366: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 367: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[0.14029542 0.29621392]\n", + " [0.12075359 0.25653407]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 369: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 370: Predicted: [[0.45436186 0.6353642 ]\n", + " [0.48908803 0.5967271 ]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 371: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 372: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[0.14400217 0.07335043]\n", + " [0.14296417 0.15161477]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 374: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 375: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 378: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 380: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 381: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 382: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 383: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 384: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 385: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 386: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 388: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 389: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 393: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 395: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 396: Predicted: [[0.6324479 0.04691634]\n", + " [0.55567926 0.17276043]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 397: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 398: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 399: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 405: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 407: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 408: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 411: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 412: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[0.7103256 0.72488344]\n", + " [0.64297694 0.75271463]], True: [[0.75 0.75]\n", + " [0. 0. ]]\n", + "Tile 414: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 416: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 419: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[0.62820077 0.86560786]\n", + " [0.5405642 0.7811286 ]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 423: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 424: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 425: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 429: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 437: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 441: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 443: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[0.3485131 0.33676207]\n", + " [0.33560023 0.31250542]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 449: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 451: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 453: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 454: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[0.42382163 0.1808674 ]\n", + " [0.42459816 0.16089258]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 457: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 458: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 459: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 460: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 462: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 466: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 467: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 468: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 469: Predicted: [[0.2382124 0.779688 ]\n", + " [0.2578609 0.7228129]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 470: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 471: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 472: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 478: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[0.6634124 0.7580183 ]\n", + " [0.6013843 0.66798043]], True: [[0.75 0.75]\n", + " [0. 0. ]]\n", + "Tile 481: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 482: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 483: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 486: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 487: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 490: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 492: Predicted: [[0.24605148 0.68068993]\n", + " [0.26949072 0.64879054]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 493: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[0.6075113 0.14258413]\n", + " [0.4309284 0.31630686]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 495: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 496: Predicted: [[0.38265592 0.64621913]\n", + " [0.42626607 0.56971467]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 497: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 499: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 500: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 505: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 507: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 509: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 512: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 513: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 517: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 519: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 522: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 523: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 524: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 526: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 529: Predicted: [[0.6422523 0.7664156 ]\n", + " [0.59900856 0.6846999 ]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 530: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 535: Predicted: [[0.38158455 0.11942971]\n", + " [0.3696971 0.15115017]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 536: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 538: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 542: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 543: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 544: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 548: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 549: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 552: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[0.8303044 0.8298563]\n", + " [0.7142611 0.6741681]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 554: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[0.48199296 0.87563443]\n", + " [0.5271681 0.8055235 ]], True: [[0.5 0.875]\n", + " [0. 0. ]]\n", + "Tile 556: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[0.3825781 0.09336449]\n", + " [0.37564564 0.11992492]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 558: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 560: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 561: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 562: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 563: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 565: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 566: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 567: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 568: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 569: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 570: Predicted: [[0.04539342 0.05734277]\n", + " [0.21942271 0.15012676]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 571: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 572: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 579: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 582: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 583: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 584: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 585: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[0.5051438 0.04198557]\n", + " [0.3612145 0.24475664]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 590: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 592: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 594: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 596: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 597: Predicted: [[0.8653408 0.14413027]\n", + " [0.71612614 0.2510162 ]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 598: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 600: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 602: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 603: Predicted: [[0.75224125 0.8219976 ]\n", + " [0.6682769 0.79371697]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 604: Predicted: [[0.21848151 0.1901168 ]\n", + " [0.18980475 0.15737191]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 605: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 606: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 608: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 609: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 610: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[0.01879573 0.20018983]\n", + " [0.09384698 0.25452173]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 613: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[0.32450247 0.59719265]\n", + " [0.3161406 0.60824203]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 617: Predicted: [[0.66527355 0.21898417]\n", + " [0.6618248 0.19859606]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 618: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 619: Predicted: [[0.46833128 0.6675267 ]\n", + " [0.4694094 0.60168403]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 620: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 622: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 623: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[0.5677551 0.8318245 ]\n", + " [0.60246074 0.7299087 ]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 625: Predicted: [[0.7667595 0.2775409 ]\n", + " [0.7387177 0.25016287]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 626: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 627: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 628: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 633: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 634: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 635: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 641: Predicted: [[0.45177794 0.92075574]\n", + " [0.49664634 0.84507674]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 642: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 643: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 645: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 647: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 648: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 649: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 650: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 651: Predicted: [[0.27330583 0.07381244]\n", + " [0.27001402 0.14355631]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 652: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 653: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 654: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 657: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[0.7391817 0.26547107]\n", + " [0.7379463 0.24241093]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 659: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 660: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 662: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 663: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 667: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[0.8965427 0.00560045]\n", + " [0.8379563 0.17582189]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[0.7447429 0.12461488]\n", + " [0.7174524 0.10948011]], True: [[0.875 0.125]\n", + " [0.875 0. ]]\n", + "Tile 674: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 676: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 677: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 679: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 688: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[0.13184635 0.9120152 ]\n", + " [0.11866637 0.71257305]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 693: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 694: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 695: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 698: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 699: Predicted: [[0.00810428 0.13654183]\n", + " [0.10015273 0.13005334]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 700: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 701: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 705: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 706: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 708: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 710: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 711: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 712: Predicted: [[0.16458218 0.30626398]\n", + " [0.15651244 0.31940633]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 713: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 715: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 716: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 717: Predicted: [[0.8416436 0.02422145]\n", + " [0.5159441 0.30647516]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 718: Predicted: [[0.07725903 0.08599041]\n", + " [0.4337124 0.41737372]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 722: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 723: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 724: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 726: Predicted: [[0.64469147 0.25488618]\n", + " [0.61706614 0.277809 ]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 727: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 729: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 730: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 731: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 733: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 734: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 735: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 741: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 742: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 746: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[0.26673493 0.2323918 ]\n", + " [0.25331348 0.19351122]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 748: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 749: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 750: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 751: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 753: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 754: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 756: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 760: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 764: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 765: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 766: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 768: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 771: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 777: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 778: Predicted: [[0.12508275 0.8361388 ]\n", + " [0.10380581 0.74074674]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 779: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 780: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 781: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 786: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 788: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 789: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 790: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 792: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 793: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 795: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 796: Predicted: [[0.47324896 0.45454472]\n", + " [0.47747695 0.45457417]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 797: Predicted: [[0.40001735 0.4536729 ]\n", + " [0.38703552 0.463475 ]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 798: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 799: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 801: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 802: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 805: Predicted: [[0.83123636 0.6220432 ]\n", + " [0.7544446 0.5692011 ]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 806: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 807: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 808: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 809: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 819: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 820: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[0.78275275 0.84615505]\n", + " [0.6148422 0.74466705]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 823: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 824: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 825: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 829: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 830: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 832: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 836: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 838: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 839: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 840: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 841: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 843: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 844: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[0.8232806 0.20360836]\n", + " [0.63841355 0.30473855]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 847: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 850: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 853: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 854: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 857: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 858: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 860: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 861: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 866: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 868: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 874: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 875: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 876: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 878: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 879: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 880: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 883: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[0.8560364 0.14187862]\n", + " [0.8035743 0.18705583]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 885: Predicted: [[0.02066156 0.2704219 ]\n", + " [0.12378582 0.38919502]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 886: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 887: Predicted: [[ 0.11776304 0.01380718]\n", + " [ 0.20445248 -0.00093484]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 888: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 889: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 894: Predicted: [[0.7251574 0.84093624]\n", + " [0.6474748 0.83271146]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 895: Predicted: [[0.39827093 0.12874234]\n", + " [0.37218443 0.1626136 ]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 896: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 901: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 904: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 909: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 912: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 917: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 918: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 919: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 920: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 921: Predicted: [[0.1392031 0.87262124]\n", + " [0.19969375 0.7109982 ]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 922: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 923: Predicted: [[0.3846943 0.30018806]\n", + " [0.37831634 0.30174264]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 924: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 928: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 930: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 935: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[0.48100445 0.06987745]\n", + " [0.49937192 0.01264995]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 937: Predicted: [[0.5082411 0.24954095]\n", + " [0.49994493 0.2273229 ]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 938: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 941: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 942: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 944: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 948: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 949: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 951: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 953: Predicted: [[0.20483464 0.56066823]\n", + " [0.20207804 0.5486798 ]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 954: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 956: Predicted: [[0.68690145 0.06816798]\n", + " [0.607032 0.11627564]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 957: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 959: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 962: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 964: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 965: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 966: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 967: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[0.42314994 0.35693374]\n", + " [0.4124576 0.34576154]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 969: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 970: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 974: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 976: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 978: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 979: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 980: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 982: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 984: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[0.23563936 0.01439214]\n", + " [0.34458268 0.03604947]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 987: Predicted: [[0.5968591 0.66455865]\n", + " [0.5919528 0.7171679 ]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 988: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 992: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 995: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 996: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[0.63274145 0.46442828]\n", + " [0.6391305 0.4491986 ]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 1001: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1002: Predicted: [[0.4587899 0.4602098 ]\n", + " [0.44436827 0.45384204]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1004: Predicted: [[0.7565594 0.50672066]\n", + " [0.74024314 0.45553982]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 1005: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1006: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[0.63970524 0.01172447]\n", + " [0.5632375 0.14153935]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 1008: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1009: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1012: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[0.5047573 0.45852703]\n", + " [0.52210313 0.50335276]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1014: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1015: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1016: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1017: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1019: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1020: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1021: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1022: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1023: Predicted: [[0.48938096 0.50982404]\n", + " [0.4493075 0.512645 ]], True: [[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "# image_index = np.random.randint(0, 120) # Randomly pick an image in the batch\n", + "image_index = 0\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 99\n", + "False Positives (FP): 1949\n", + "False Negatives (FN): 0\n", + "Precision: 0.0483, Recall: 1.0000\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "\n", + "threshold = 0.1 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits): \n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1* tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 97\n", + "False Positives (FP): 1951\n", + "False Negatives (FN): 2\n", + "Precision: 0.0474, Recall: 0.9798\n" + ] + } + ], + "source": [ + "\n", + "\n", + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.1\n", + "tile_size = 8\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " matched_true_hits = set()\n", + " matched_predictions = set()\n", + "\n", + " for pred_idx, pred in enumerate(valid_predicted_hits):\n", + " if pred_idx in matched_predictions:\n", + " continue\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 0.5 *tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " matched_predictions.add(pred_idx)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage\n", + "tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# Plotting\n", + "fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "for i in range(4):\n", + " ax[i].imshow(tiles[i], cmap='gray')\n", + " ax[i].set_title(f\"Tile {i}\")\n", + " ax[i].axis('off')\n", + "\n", + "ax[4].imshow(reconstructed_image, cmap='gray')\n", + "ax[4].set_title(\"Reconstructed Image\")\n", + "ax[4].axis('off')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.1):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "c = np.random.randint(0,120)\n", + "image_index = 0 # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First image's first tile:\n", + "tf.Tensor(\n", + "[[0. ]\n", + " [0. ]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0. ]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0.00392157]], shape=(8, 1), dtype=float64)\n", + "First image's second tile:\n", + "tf.Tensor(\n", + "[[0. ]\n", + " [0. ]\n", + " [0.00784314]\n", + " [0.00392157]\n", + " [0.00784314]\n", + " [0.00392157]\n", + " [0. ]\n", + " [0.00392157]], shape=(8, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "for val_images, val_centers in val_dataset.take(1):\n", + " print(\"First image's first tile:\")\n", + " print(val_images[2, 0]) # Tile 0 of Image 0\n", + " print(\"First image's second tile:\")\n", + " print(val_images[2, 1]) # Tile 1 of Image 0\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sod", + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/Solving Tiling Problem fo Hungarian Loss copy.ipynb b/Computer Vision_Object Detection/Solving Tiling Problem fo Hungarian Loss copy.ipynb new file mode 100644 index 0000000..b28a6fc --- /dev/null +++ b/Computer Vision_Object Detection/Solving Tiling Problem fo Hungarian Loss copy.ipynb @@ -0,0 +1,5169 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:16:26.058477: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-20 13:16:26.071422: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-20 13:16:26.084358: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-20 13:16:26.088218: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-20 13:16:26.099259: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-20 13:16:26.736821: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:16:27.910509: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"]) \n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import tensorflow as tf\n", + "# from tensorflow.keras import layers, Model\n", + "# from sklearn.model_selection import train_test_split\n", + "# import h5py\n", + "\n", + "# class DataLoader:\n", + "# def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + "# self.h5_filename = h5_filename\n", + "# self.tile_size = tile_size\n", + "# self.max_hits_per_tile = max_hits_per_tile\n", + "# self.images, self.centers = self.load_data()\n", + "\n", + "# def load_data(self):\n", + "# with h5py.File(self.h5_filename, 'r') as f:\n", + "# images = np.array(f['images'])\n", + "# centers = np.array(f['centers_training'])\n", + "# return images, centers\n", + "\n", + "# def tile_image(self, image):\n", + "# tiles = []\n", + "# for i in range(0, image.shape[0], self.tile_size):\n", + "# for j in range(0, image.shape[1], self.tile_size):\n", + "# tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + "# tiles.append(tile)\n", + "# return np.array(tiles)\n", + "\n", + "# def map_hits_to_tiles(self, image, centers):\n", + "# tiles = self.tile_image(image)\n", + "# hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + "# for hit in centers:\n", + "# _, x, y = hit\n", + "# tile_row = int(y // self.tile_size)\n", + "# tile_col = int(x // self.tile_size)\n", + "# tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + "# local_x = x % self.tile_size\n", + "# local_y = y % self.tile_size\n", + "# hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + "# return tiles, hits_per_tile\n", + "\n", + "# def process_data(self):\n", + "# tiled_images = []\n", + "# tiled_centers = []\n", + "\n", + "# for img_idx in range(len(self.images)):\n", + "# image = self.images[img_idx]\n", + "# centers = self.centers[img_idx]\n", + "# tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + "# tiled_images.append(tiles)\n", + "\n", + "# tile_hits_list = [\n", + "# hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + "# for i in range(len(tiles))\n", + "# ]\n", + "# tiled_centers.append(tile_hits_list)\n", + "\n", + "# return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + "# def normalize_data(self):\n", + "# tiled_images, tiled_centers = self.process_data()\n", + "# normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + "# # Adjust the representation to include a \"presence\" flag\n", + "# normalized_centers = []\n", + "# for image in tiled_centers:\n", + "# adjusted_image = []\n", + "# for tile in image:\n", + "# adjusted_tile = []\n", + "# for x, y in tile:\n", + "# if (x, y) == (0, 0): # No object\n", + "# adjusted_tile.append([0, 0, 0]) # [presence, x, y]\n", + "# else: # Object\n", + "# adjusted_tile.append([1, x / self.tile_size, y / self.tile_size])\n", + "# adjusted_image.append(adjusted_tile)\n", + "# normalized_centers.append(adjusted_image)\n", + "\n", + "# return normalized_images, np.array(normalized_centers)\n", + "\n", + "# def create_datasets(data_loader, train_size=0.95):\n", + "# # Normalize data\n", + "# normalized_images, normalized_centers = data_loader.normalize_data()\n", + "# train_images, val_images, train_centers, val_centers = train_test_split(\n", + "# normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + "# )\n", + "\n", + "# # Flatten tiles for individual input to the model\n", + "# train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "\n", + "# train_centers_flat = train_centers.reshape(-1, 2, 3) # Adjusted to include [presence, x, y]\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 3)\n", + "\n", + "# # Create TensorFlow datasets\n", + "# batch_size = 2048*20\n", + "# train_dataset = (\n", + "# tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat))\n", + "# .batch(batch_size)\n", + "# .cache()\n", + "# .prefetch(tf.data.AUTOTUNE)\n", + "# )\n", + "# val_dataset = (\n", + "# tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat))\n", + "# .batch(batch_size)\n", + "# .cache()\n", + "# .prefetch(tf.data.AUTOTUNE)\n", + "# )\n", + "\n", + "# return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:5000])\n", + " centers = np.array(f['centers_training'][:5000])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def create_datasets(data_loader, train_size=0.95):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + " val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "\n", + " train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + " val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + " # Create TensorFlow datasets\n", + " batch_size = 20480 * 20\n", + " train_dataset = (\n", + " tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat))\n", + " .batch(batch_size)\n", + " .cache()\n", + " .prefetch(tf.data.AUTOTUNE)\n", + " )\n", + " val_dataset = (\n", + " tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat))\n", + " .batch(batch_size)\n", + " .cache()\n", + " .prefetch(tf.data.AUTOTUNE)\n", + " )\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/30KFixed_100_256by256_RandomindexNoNoise.h5'\n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " ...,\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]]],\n", + "\n", + "\n", + " [[[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " ...,\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]]],\n", + "\n", + "\n", + " [[[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " ...,\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]]],\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + " [[[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " ...,\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]]],\n", + "\n", + "\n", + " [[[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " ...,\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]]],\n", + "\n", + "\n", + " [[[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " ...,\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]],\n", + "\n", + " [[0., 0.],\n", + " [0., 0.]]]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(image, )\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.2)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.2)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,100)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + " x = layers.Dense(128, activation='relu')(x)\n", + " \n", + " # Instead of 2*x,y = 4 units, we do 2*(obj_conf + x + y) = 6 units\n", + " outputs = layers.Dense(max_hits * 3, activation='sigmoid')(x)\n", + " outputs = layers.Reshape((max_hits, 3))(outputs)\n", + "\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((9500, 1024, 8, 8), (500, 1024, 8, 8), (9500, 1024, 2, 2), (500, 1024, 2, 2))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### no object loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "@tf.function\n", + "def hungarian_loss_with_conf(\n", + " y_true, y_pred,\n", + " lambda_noobj=1.0,\n", + " lambda_obj=5.0,\n", + " lambda_coords=5.0\n", + "):\n", + " \"\"\"\n", + " Vectorized Hungarian-style loss for up to 2 objects per tile.\n", + "\n", + " y_pred: (batch, 2, 3)\n", + " => for each of up to 2 prediction slots: [conf_logit, x, y]\n", + " y_true: (batch, 2, 3)\n", + " => for each of up to 2 GT slots: [obj, x, y], with obj ∈ {0,1}.\n", + "\n", + " Returns:\n", + " A scalar (mean loss over the batch).\n", + " \"\"\"\n", + "\n", + " # ----------------------------------------------------------------\n", + " # 1) Separate out the confidence and coordinates from predictions\n", + " # ----------------------------------------------------------------\n", + " pred_conf = y_pred[..., 0] # (batch, 2)\n", + " pred_xy = y_pred[..., 1:3] # (batch, 2, 2)\n", + "\n", + " # 2) Separate the object-flag and coordinates from ground truth\n", + " true_obj = y_true[..., 0] # (batch, 2)\n", + " true_xy = y_true[..., 1:3] # (batch, 2, 2)\n", + "\n", + " # 3) Count how many objects in each tile (0, 1, or 2)\n", + " # => shape (batch,)\n", + " n_obj = tf.reduce_sum(tf.cast(true_obj > 0.5, tf.int32), axis=-1)\n", + "\n", + " # ----------------------------------------------------------------\n", + " # 4) Mask out the 3 scenarios\n", + " # ----------------------------------------------------------------\n", + " mask0 = tf.cast(tf.equal(n_obj, 0), tf.float32) # shape (batch,)\n", + " mask1 = tf.cast(tf.equal(n_obj, 1), tf.float32)\n", + " mask2 = tf.cast(tf.equal(n_obj, 2), tf.float32)\n", + "\n", + " # Expand dims so we can multiply (batch,) by (batch,) or add easily\n", + " # but typically we'll just do elementwise * later and rely on broadcast\n", + " # if needed. It's enough to keep them as (batch,).\n", + "\n", + " # ----------------------------------------------------------------\n", + " # 5) CASE 0: No objects => All confidences should be 0\n", + " # Summation of BCE with label=0 for each of the 2 slots\n", + " # ----------------------------------------------------------------\n", + " # shape (batch, 2)\n", + " conf_loss0 = tf.nn.sigmoid_cross_entropy_with_logits(\n", + " labels=tf.zeros_like(pred_conf),\n", + " logits=pred_conf\n", + " )\n", + " # Sum across the 2 slots => shape (batch,)\n", + " cost0 = tf.reduce_sum(conf_loss0, axis=-1)\n", + " # Weighted\n", + " cost0 = lambda_noobj * cost0\n", + "\n", + " # ----------------------------------------------------------------\n", + " # 6) CASE 1: Exactly 1 object => Decide if pred slot 0 or slot 1\n", + " # is matched. We'll compute distances to the \"first\" GT object.\n", + " # ----------------------------------------------------------------\n", + " # By convention, let's assume the first ground-truth object is in row 0,\n", + " # and the second row is 0 if there's only 1 object. Alternatively, we\n", + " # could gather the row where `obj=1`, but let's assume row 0 is it.\n", + " #\n", + " # Distances from each predicted slot to the (first) GT object => shape (batch,)\n", + " dist_pred0_gt0 = tf.reduce_sum(\n", + " tf.square(pred_xy[:, 0] - true_xy[:, 0]), axis=-1\n", + " ) # (batch,)\n", + " dist_pred1_gt0 = tf.reduce_sum(\n", + " tf.square(pred_xy[:, 1] - true_xy[:, 0]), axis=-1\n", + " )\n", + "\n", + " # We choose whichever slot yields minimal coordinate cost:\n", + " # matched0 = (dist_pred0_gt0 < dist_pred1_gt0)\n", + " # => if True, slot0 is matched => conf0=1, conf1=0\n", + " # if False, slot1 is matched => conf1=1, conf0=0\n", + " matched0 = tf.less(dist_pred0_gt0, dist_pred1_gt0) # bool (batch,)\n", + "\n", + " # Minimum coordinate cost for each sample\n", + " best_coord_1 = tf.where(matched0, dist_pred0_gt0, dist_pred1_gt0) # (batch,)\n", + "\n", + " # Now build conf_labels => shape (batch, 2). \n", + " # If matched0[i] is True => [1, 0], else [0, 1].\n", + " conf_label_slot0 = tf.where(matched0, 1.0, 0.0)\n", + " conf_label_slot1 = tf.where(matched0, 0.0, 1.0)\n", + " conf_labels_1 = tf.stack([conf_label_slot0, conf_label_slot1], axis=-1) # (batch,2)\n", + "\n", + " conf_loss1 = tf.nn.sigmoid_cross_entropy_with_logits(\n", + " labels=conf_labels_1,\n", + " logits=pred_conf\n", + " ) # shape (batch,2)\n", + " conf_loss1 = tf.reduce_sum(conf_loss1, axis=-1) # shape (batch,)\n", + "\n", + " # Weighted sum => coordinate + objectness\n", + " cost1 = lambda_obj * conf_loss1 + lambda_coords * best_coord_1\n", + "\n", + " # ----------------------------------------------------------------\n", + " # 7) CASE 2: 2 objects => 2 permutations to check\n", + " # ----------------------------------------------------------------\n", + " # Distances:\n", + " dist_pred0_gt0 = tf.reduce_sum(\n", + " tf.square(pred_xy[:, 0] - true_xy[:, 0]), axis=-1\n", + " ) # (batch,)\n", + " dist_pred0_gt1 = tf.reduce_sum(\n", + " tf.square(pred_xy[:, 0] - true_xy[:, 1]), axis=-1\n", + " )\n", + " dist_pred1_gt0 = tf.reduce_sum(\n", + " tf.square(pred_xy[:, 1] - true_xy[:, 0]), axis=-1\n", + " )\n", + " dist_pred1_gt1 = tf.reduce_sum(\n", + " tf.square(pred_xy[:, 1] - true_xy[:, 1]), axis=-1\n", + " )\n", + "\n", + " # cost_1 => (pred0->gt0) + (pred1->gt1)\n", + " cost_1 = dist_pred0_gt0 + dist_pred1_gt1\n", + " # cost_2 => (pred0->gt1) + (pred1->gt0)\n", + " cost_2 = dist_pred0_gt1 + dist_pred1_gt0\n", + "\n", + " # Best coordinate cost => shape (batch,)\n", + " best_coord_2 = tf.minimum(cost_1, cost_2)\n", + "\n", + " # For n_obj=2, both predicted slots are matched => conf labels = [1, 1].\n", + " conf_labels_2 = tf.ones_like(pred_conf, dtype=tf.float32) # shape (batch,2)\n", + " conf_loss2 = tf.nn.sigmoid_cross_entropy_with_logits(\n", + " labels=conf_labels_2,\n", + " logits=pred_conf\n", + " )\n", + " conf_loss2 = tf.reduce_sum(conf_loss2, axis=-1) # (batch,)\n", + "\n", + " cost2 = lambda_obj * conf_loss2 + lambda_coords * best_coord_2\n", + "\n", + " # ----------------------------------------------------------------\n", + " # 8) Combine the scenarios via the masks\n", + " # ----------------------------------------------------------------\n", + " # shape (batch,)\n", + " total_cost = (mask0 * cost0) + (mask1 * cost1) + (mask2 * cost2)\n", + "\n", + " # Final mean over the batch\n", + " return tf.reduce_mean(total_cost)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 6)              │           774 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape (Reshape)               │ (None, 2, 3)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m) │ \u001b[38;5;34m774\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 84,166 (328.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m84,166\u001b[0m (328.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 84,166 (328.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m84,166\u001b[0m (328.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# loss_fn, m0, m1, m2, m3 = make_hungarian_loss_3_and_metrics(\n", + "# w_0=1.0, w_1=5.0, w_2=5.0, w_3=5.0\n", + "# )\n", + "\n", + "# Get the 4 callables\n", + "# loss_fn, metric0, metric1, metric2 = make_hungarian_loss_and_metrics(w_0=1, w_1=1, w_2=3)\n", + "\n", + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(optimizer='adam', loss=hungarian_loss_with_conf)\n", + "\n", + "\n", + "\n", + "\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<_PrefetchDataset element_spec=(TensorSpec(shape=(None, 8, 8, 1), dtype=tf.float64, name=None), TensorSpec(shape=(None, 2, 3), dtype=tf.float64, name=None))>" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:18:10.220982: W tensorflow/core/kernels/gpu_utils.cc:68] Failed to allocate memory for convolution redzone checking; skipping this check. This is benign and only means that we won't check cudnn for out-of-bounds reads and writes. This message will only be printed once.\n", + "2025-01-20 13:18:10.228657: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1737397090.287412 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.325911 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.332636 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.337121 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.381675 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.436129 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.436223 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.496400 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.514100 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.532336 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.557059 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.580982 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.611032 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.639365 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.656717 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.703640 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.763569 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.805102 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.929258 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.934245 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.938873 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397090.996010 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.000824 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.210468 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.218212 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.222740 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.227359 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.232038 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.236667 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.241238 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.247914 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.252983 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.258191 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.263303 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.268955 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.274686 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.282593 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.287948 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.293321 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.301984 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.308903 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.317990 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397091.326906 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.477336 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.486824 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.496030 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.506491 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.521864 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.532970 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.542396 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.553196 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.564824 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.573860 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.585569 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.597353 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.609858 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.618880 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.631042 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.646023 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.660911 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.673633 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.694187 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.711426 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.739564 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.961157 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397092.991209 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.414091 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.422688 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.429746 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.436422 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.443547 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.449635 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.455834 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.462745 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.470075 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.478667 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.487965 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.495243 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.505809 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.523932 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.684261 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.707418 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.740976 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.772791 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.804543 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.836081 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.872547 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.888855 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397093.888916 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397094.063623 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/24\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:14\u001b[0m 6s/step - loss: 2.1677" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737397094.120191 143883 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m23/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 485ms/step - loss: 2.1134" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:18:25.130543: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2025-01-20 13:18:25.130718: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1737397105.141506 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.146850 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.151924 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.152024 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.158964 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.199701 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.199763 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.220347 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.258696 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.271998 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.285714 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.304345 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.322329 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.344957 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.366169 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.379108 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.414324 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.459186 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.490333 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.518276 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.540926 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.544471 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.587384 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.591010 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.748324 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.754164 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.757617 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.761072 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.764619 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.768132 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.771616 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.776589 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.823832 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.827673 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.833600 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.837532 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.841791 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.846167 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.851892 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.855940 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.860036 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.866603 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.872001 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.879134 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.886106 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.915152 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.922476 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.929575 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.937635 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.949076 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.957499 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.964688 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.976127 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.985079 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397105.991196 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.000005 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.008985 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.018514 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.025399 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.034750 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.046271 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.057604 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.067250 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.082859 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.095967 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.117367 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.284116 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.306685 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.608491 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.616269 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.621569 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.626580 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.631947 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.636506 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.641170 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.646325 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.651838 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.658297 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.665293 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.669902 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.677870 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.691534 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.716062 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.827139 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.852445 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.876354 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.900235 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.923976 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.951411 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.963742 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397106.963800 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 565ms/step - loss: 2.1082" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737397107.093265 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397107.135828 143890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.076056 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.085416 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.094680 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.110581 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.118933 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.128815 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.137085 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.145787 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.159722 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.174311 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.188087 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.198635 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.217122 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.231002 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.246237 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.260122 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.275565 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.289673 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.305316 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.316482 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.329375 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.366695 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.439638 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.448917 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.457886 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.521403 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.539692 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.554502 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.573920 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.600363 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.651074 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.671263 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.687711 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.731086 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397108.800108 143889 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "2025-01-20 13:18:29.090067: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1737397109.107333 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.109714 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.111990 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.114570 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.116749 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.119069 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.121817 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.124279 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.127907 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.131049 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.133948 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.136834 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.140809 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.144499 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.148543 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.152235 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.155837 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.158801 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.162512 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.166603 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.175960 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.179349 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.197757 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.199093 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.201571 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.217679 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.226885 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.231674 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.235621 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.240455 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.247313 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.260199 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.265461 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.269688 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397109.280492 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 656ms/step - loss: 2.1034 - val_loss: 1.6296 - learning_rate: 0.0010\n", + "Epoch 2/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737397109.297961 143887 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 313ms/step - loss: 1.6125 - val_loss: 1.5959 - learning_rate: 0.0010\n", + "Epoch 3/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:18:38.807244: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 270ms/step - loss: 1.5969 - val_loss: 1.5939 - learning_rate: 0.0010\n", + "Epoch 4/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 266ms/step - loss: 1.5942 - val_loss: 1.5911 - learning_rate: 0.0010\n", + "Epoch 5/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:18:53.574116: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 284ms/step - loss: 1.5917 - val_loss: 1.5904 - learning_rate: 0.0010\n", + "Epoch 6/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 265ms/step - loss: 1.5912 - val_loss: 1.5900 - learning_rate: 0.0010\n", + "Epoch 7/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 270ms/step - loss: 1.5908 - val_loss: 1.5895 - learning_rate: 0.0010\n", + "Epoch 8/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 231ms/step - loss: 1.5902 - val_loss: 1.5888 - learning_rate: 0.0010\n", + "Epoch 9/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:19:21.846518: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 267ms/step - loss: 1.5896 - val_loss: 1.5884 - learning_rate: 0.0010\n", + "Epoch 10/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 270ms/step - loss: 1.5893 - val_loss: 1.5882 - learning_rate: 0.0010\n", + "Epoch 11/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 231ms/step - loss: 1.5890 - val_loss: 1.5880 - learning_rate: 0.0010\n", + "Epoch 12/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 265ms/step - loss: 1.5889 - val_loss: 1.5878 - learning_rate: 0.0010\n", + "Epoch 13/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 237ms/step - loss: 1.5887 - val_loss: 1.5877 - learning_rate: 0.0010\n", + "Epoch 14/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 266ms/step - loss: 1.5885 - val_loss: 1.5875 - learning_rate: 0.0010\n", + "Epoch 15/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 232ms/step - loss: 1.5883 - val_loss: 1.5873 - learning_rate: 0.0010\n", + "Epoch 16/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 266ms/step - loss: 1.5882 - val_loss: 1.5873 - learning_rate: 0.0010\n", + "Epoch 17/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:20:15.574767: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 262ms/step - loss: 1.5881 - val_loss: 1.5872 - learning_rate: 0.0010\n", + "Epoch 18/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 240ms/step - loss: 1.5881 - val_loss: 1.5871 - learning_rate: 0.0010\n", + "Epoch 19/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 231ms/step - loss: 1.5880 - val_loss: 1.5871 - learning_rate: 0.0010\n", + "Epoch 20/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 266ms/step - loss: 1.5880 - val_loss: 1.5871 - learning_rate: 0.0010\n", + "Epoch 21/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 235ms/step - loss: 1.5880 - val_loss: 1.5871 - learning_rate: 0.0010\n", + "Epoch 22/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 266ms/step - loss: 1.5879 - val_loss: 1.5870 - learning_rate: 0.0010\n", + "Epoch 23/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 232ms/step - loss: 1.5879 - val_loss: 1.5870 - learning_rate: 0.0010\n", + "Epoch 24/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5879 - val_loss: 1.5870 - learning_rate: 0.0010\n", + "Epoch 25/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 267ms/step - loss: 1.5878 - val_loss: 1.5869 - learning_rate: 0.0010\n", + "Epoch 26/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5878 - val_loss: 1.5869 - learning_rate: 0.0010\n", + "Epoch 27/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 271ms/step - loss: 1.5878 - val_loss: 1.5869 - learning_rate: 0.0010\n", + "Epoch 28/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5878 - val_loss: 1.5868 - learning_rate: 0.0010\n", + "Epoch 29/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 232ms/step - loss: 1.5877 - val_loss: 1.5868 - learning_rate: 0.0010\n", + "Epoch 30/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 251ms/step - loss: 1.5877 - val_loss: 1.5868 - learning_rate: 0.0010\n", + "Epoch 31/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 247ms/step - loss: 1.5877 - val_loss: 1.5868 - learning_rate: 0.0010\n", + "Epoch 32/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5877 - val_loss: 1.5868 - learning_rate: 0.0010\n", + "Epoch 33/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 13:21:56.742759: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5876 - val_loss: 1.5867 - learning_rate: 0.0010\n", + "Epoch 34/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 270ms/step - loss: 1.5876 - val_loss: 1.5867 - learning_rate: 0.0010\n", + "Epoch 35/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5876 - val_loss: 1.5867 - learning_rate: 0.0010\n", + "Epoch 36/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 231ms/step - loss: 1.5876 - val_loss: 1.5867 - learning_rate: 0.0010\n", + "Epoch 37/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 264ms/step - loss: 1.5876 - val_loss: 1.5867 - learning_rate: 0.0010\n", + "Epoch 38/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 233ms/step - loss: 1.5876 - val_loss: 1.5867 - learning_rate: 0.0010\n", + "Epoch 39/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5876 - val_loss: 1.5867 - learning_rate: 0.0010\n", + "Epoch 40/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 267ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 41/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 235ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 42/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 232ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 43/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 44/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 263ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 45/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 46/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 245ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 47/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 258ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 48/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 232ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 49/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 232ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n", + "Epoch 50/50\n", + "\u001b[1m24/24\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 256ms/step - loss: 1.5875 - val_loss: 1.5866 - learning_rate: 0.0010\n" + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=50,\n", + " \n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/20KFixed_10_256by256_RandomindexNoNoise_linear_HungarianLoss_with metrics_4x4.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/10KFixed_100_256by256_95indexNoNoise_linear_custom_HungarianLoss.keras')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m192/640\u001b[0m \u001b[32m━━━━━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 791us/step" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737397438.913240 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.913790 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.914135 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.914402 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.914670 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.914930 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.915188 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.915473 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.915733 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.915994 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.916272 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.916545 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.917021 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.917342 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.917635 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.917891 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.918169 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.918459 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.918756 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.919058 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.919351 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.928062 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737397438.928404 143888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m640/640\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 737us/step\n", + "Predicted centers shape: (30, 1024, 2, 2)\n", + "Grouped targets shape: (20, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "# # # Flatten validation images and centers\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "\n", + "# Batch size for n images\n", + "batch = 20* 1024 # number of images per batch\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch)\n", + "# Make predictions on dataset\n", + "# inputs, targets = next(iter(val_dataset)) # Extract a batch\n", + "inputs, targets = next(iter(train_dataset)) # Extract a batch\n", + "outputs = model.predict(inputs)\n", + "\n", + "# Reshape predictions and targets back to image structure\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 2)\n", + "\n", + "# Print the shapes\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\") # (batch_size // 1024, 1024, 2, 2)\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\") # (batch_size // 1024, 1024, 2, 2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train_images shape: (4750, 1024, 8, 8)\n", + "train_centers shape: (4750, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "print(f\"train_images shape: {train_images.shape}\")\n", + "print(f\"train_centers shape: {train_centers.shape}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train_images_flat shape: (4864000, 8, 8, 1)\n", + "train_centers_flat shape: (4864000, 2, 2)\n" + ] + } + ], + "source": [ + "print(f\"train_images_flat shape: {train_images_flat.shape}\")\n", + "print(f\"train_centers_flat shape: {train_centers_flat.shape}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 15:\n", + "Tile 0: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[1.2051764e-06 3.3410335e-01]\n", + " [3.3682579e-01 3.0244360e-07]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 4: Predicted: [[2.3160423e-01 2.3282726e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 5: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 6: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 7: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [1.77035672e-05 6.61778510e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 11: Predicted: [[6.5278989e-01 6.9728816e-07]\n", + " [5.7468319e-01 5.7805330e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[8.3706063e-06 4.9026415e-01]\n", + " [4.9074847e-01 8.5230073e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[3.4829634e-01 3.5316411e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[7.8300030e-07 8.7189454e-01]\n", + " [8.7189496e-01 4.9897380e-08]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[2.2266424e-01 2.2511165e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 18: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [6.43889689e-06 5.02293825e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[5.0623649e-01 8.0817529e-08]\n", + " [4.0677312e-01 4.1329479e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.625 0.875]\n", + " [0.5 0.125]]\n", + "Tile 23: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 24: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [4.30922825e-10 6.65537953e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[6.8304384e-01 4.3295442e-14]\n", + " [2.7501106e-01 3.1758741e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 28: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [6.64136621e-07 2.85804808e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 29: Predicted: [[2.8967017e-01 3.7464375e-07]\n", + " [6.5256439e-02 7.0116781e-02]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 30: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 31: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 34: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 35: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 37: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 38: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 44: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 46: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 48: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 49: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 51: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 53: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 55: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[7.7606120e-07 3.8836306e-01]\n", + " [3.9206585e-01 5.8670491e-08]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[2.8394991e-01 2.8725293e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 59: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 61: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 63: Predicted: [[5.1025983e-10 5.3102201e-01]\n", + " [4.8177403e-01 2.4276829e-09]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 64: Predicted: [[6.2075116e-05 1.1676058e-04]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 65: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 66: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.5 0.875]\n", + " [0. 0. ]]\n", + "Tile 67: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 68: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 69: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 71: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 73: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 76: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 77: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 80: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 85: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 86: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 87: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 88: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 90: Predicted: [[5.541674e-09 5.730802e-01]\n", + " [5.670170e-01 5.472765e-10]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 91: Predicted: [[2.4894707e-01 2.5769764e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0.125 0.625]\n", + " [0. 0. ]]\n", + "Tile 92: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 93: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 95: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 96: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 98: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 99: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 100: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 102: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 103: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 106: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 108: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 111: Predicted: [[1.5345895e-05 6.2538326e-01]\n", + " [6.2532866e-01 1.2533767e-08]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 112: Predicted: [[5.1678449e-01 5.1911348e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 113: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 114: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 118: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 119: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 120: Predicted: [[9.3879578e-07 3.4581897e-01]\n", + " [3.5031107e-01 2.2775365e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[2.4035096e-01 2.4182764e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 122: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 124: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 126: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 127: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 129: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.05258543e-09 1.97828978e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 131: Predicted: [[1.7884818e-01 1.5943234e-08]\n", + " [2.0653331e-04 2.8416145e-04]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [4.19377284e-06 7.73360074e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 134: Predicted: [[7.6499569e-01 7.3492906e-08]\n", + " [3.5305858e-01 3.5825020e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 140: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 141: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 142: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 143: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 145: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 147: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 149: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 151: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.5 0.125]\n", + " [0. 0. ]]\n", + "Tile 155: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 160: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 161: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 162: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 164: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 165: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 166: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 167: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 169: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 171: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 172: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 174: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[1.0692905e-08 5.3975773e-01]\n", + " [5.2929312e-01 1.6138455e-09]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[2.3878917e-01 2.4597894e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 179: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 180: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [6.49581170e-06 8.98836493e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 182: Predicted: [[9.0118009e-01 8.6306828e-10]\n", + " [7.5761479e-01 7.7833927e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 184: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 186: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 188: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 190: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 192: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 194: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 196: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 198: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 199: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 201: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 202: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 205: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 206: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 207: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 210: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 211: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 212: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 213: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 214: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 215: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 216: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 217: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 218: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 219: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 220: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 222: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 225: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 226: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.875]\n", + " [0.875 0.375]]\n", + "Tile 227: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 228: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [8.30188924e-07 5.76161921e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 230: Predicted: [[5.6984353e-01 6.5771889e-07]\n", + " [3.3825513e-02 3.5573661e-02]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 231: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 234: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 236: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 237: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 238: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 239: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 240: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 241: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 242: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 244: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 245: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 246: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 247: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 249: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 253: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 254: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 255: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 257: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 258: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 259: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 262: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 264: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 266: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 267: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 268: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[3.7526850e-06 8.5927898e-01]\n", + " [8.5466695e-01 7.3275106e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[2.2805433e-01 2.2145839e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 272: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 273: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 274: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 278: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 279: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 280: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.125 0.625]\n", + " [0. 0. ]]\n", + "Tile 281: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 283: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.375 0.125]\n", + " [0.5 0.75 ]]\n", + "Tile 284: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 286: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 287: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 288: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 290: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 291: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 292: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 293: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 294: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 295: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 296: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 297: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 298: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [5.37497904e-08 5.06213605e-01]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 299: Predicted: [[4.9614426e-01 9.6831043e-10]\n", + " [3.4760487e-01 3.4166577e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 300: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 302: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 303: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 304: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 305: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 307: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 309: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 310: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 311: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 313: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [4.70797677e-05 7.60822415e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 314: Predicted: [[7.6256627e-01 5.4461441e-07]\n", + " [6.2838793e-01 6.2327588e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 315: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 317: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 318: Predicted: [[1.91899883e-08 1.23358645e-01]\n", + " [1.34319097e-01 1.49883903e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[3.0043698e-04 3.9268009e-04]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 320: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 321: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 325: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 328: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 330: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 333: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 334: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 336: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 337: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [9.16088325e-08 6.42607868e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 338: Predicted: [[6.3163602e-01 2.2329164e-07]\n", + " [1.1171178e-03 1.5860996e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 339: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 340: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 342: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 344: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 345: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 347: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 349: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 350: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 351: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [1.51881295e-05 6.25137627e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 353: Predicted: [[6.2579548e-01 1.5401309e-08]\n", + " [5.1462394e-01 5.1807088e-01]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 354: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 355: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 356: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 362: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 365: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 366: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 367: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 369: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 370: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 371: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 372: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 374: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 375: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [9.89035787e-09 3.95397514e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[3.9245009e-01 4.5092843e-10]\n", + " [2.4845383e-01 2.4846348e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 378: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [7.00993269e-07 3.46292347e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 380: Predicted: [[3.5523438e-01 1.6269588e-07]\n", + " [2.3499577e-01 2.3675504e-01]], True: [[0.5 0.875]\n", + " [0. 0. ]]\n", + "Tile 381: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 382: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 383: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 384: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 385: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 386: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 388: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 389: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 393: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [3.16736390e-07 4.16597545e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 395: Predicted: [[4.1225234e-01 4.0125923e-07]\n", + " [1.1976905e-02 1.3687282e-02]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 396: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 397: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 398: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 399: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 405: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 407: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 408: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 411: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 412: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [1.92563419e-07 3.99297208e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[3.9929259e-01 3.0706840e-08]\n", + " [2.5387663e-01 2.5558490e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 414: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 416: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 419: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [5.78299432e-06 5.16211033e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[5.1183361e-01 8.0378544e-07]\n", + " [3.8213533e-01 3.7655461e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 423: Predicted: [[5.3706549e-07 6.0381889e-01]\n", + " [6.0170889e-01 1.2189636e-07]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 424: Predicted: [[1.8947837e-01 1.9839968e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 425: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 429: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [9.67602609e-05 7.38815904e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[7.5035113e-01 5.2902305e-07]\n", + " [6.0350472e-01 6.0481471e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[5.8199862e-06 6.2646312e-01]\n", + " [6.2470055e-01 1.2287743e-10]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[4.9968609e-01 4.9564257e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 437: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 441: Predicted: [[1.9350443e-06 3.8989696e-01]\n", + " [3.8939264e-01 1.3952608e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[2.4620245e-01 2.5676814e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 443: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 449: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 451: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 453: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 454: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 457: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 458: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 459: Predicted: [[3.2756822e-07 3.6760816e-01]\n", + " [3.5986593e-01 4.5703433e-07]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 460: Predicted: [[1.0013854e-02 1.1514633e-02]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 462: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 466: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 467: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 468: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 469: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 470: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 471: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 472: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[1.0101561e-05 6.2485498e-01]\n", + " [6.1884332e-01 5.8279678e-08]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[4.9481198e-01 4.9419078e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 478: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 481: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 482: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 483: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 486: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 487: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 490: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 492: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 493: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 495: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 496: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 497: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 499: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 500: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 505: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 507: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 509: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 512: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 513: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 517: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 519: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [1.40834084e-06 6.42540097e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[6.3491213e-01 2.3722913e-07]\n", + " [1.9442211e-01 2.0637615e-01]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 522: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 523: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 524: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 526: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 529: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 530: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 535: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 536: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 538: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 542: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 543: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 544: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 548: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 549: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 552: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 554: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 556: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 558: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 560: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 561: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 562: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 563: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 565: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 566: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 567: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 568: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 569: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 570: Predicted: [[5.4170897e-07 3.4249756e-01]\n", + " [3.3704707e-01 7.2974677e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 571: Predicted: [[1.1733332e-02 1.3293188e-02]\n", + " [2.9973734e-07 6.0457200e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 572: Predicted: [[5.9811831e-01 1.6326640e-08]\n", + " [1.5754415e-01 1.6692773e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 579: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [5.94395578e-06 8.67682159e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[8.6772227e-01 6.7710651e-08]\n", + " [6.8859124e-01 6.7038274e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 582: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 583: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 584: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 585: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 590: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 592: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [1.45643003e-06 2.27471679e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[2.35139728e-01 6.76185607e-07]\n", + " [1.14716098e-01 1.18477486e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 594: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 596: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 597: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 598: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 600: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 602: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 603: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 604: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 605: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 606: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 608: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 609: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 610: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 613: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.84047341e-10 2.98538983e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[3.0270487e-01 6.4428712e-11]\n", + " [1.2525727e-01 1.2966569e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 617: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 618: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 619: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 620: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[1.69023773e-09 5.91533840e-01]\n", + " [5.79044878e-01 1.07742926e-10]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 622: Predicted: [[2.7858472e-01 2.9107660e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 623: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[2.0066476e-07 6.6966796e-01]\n", + " [6.8493205e-01 1.0466299e-09]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 625: Predicted: [[3.5843110e-01 3.7057719e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 626: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 627: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 628: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 633: Predicted: [[8.9998480e-07 5.8939034e-01]\n", + " [5.8355308e-01 6.8787296e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 634: Predicted: [[3.7014190e-02 3.8659628e-02]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 635: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 641: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 642: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 643: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 645: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 647: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 648: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 649: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 650: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 651: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 652: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.25 0.375]\n", + " [0.125 0.625]]\n", + "Tile 653: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 654: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 657: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 659: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 660: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 662: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 663: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 667: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 674: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 676: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 677: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 679: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [3.12544398e-06 3.72692049e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[3.7574932e-01 5.6350734e-07]\n", + " [2.5357044e-01 2.5470319e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 688: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [1.36522530e-07 4.46970403e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[5.0012767e-01 7.8027362e-10]\n", + " [2.7449626e-01 2.8525460e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.16885428e-06 7.81011879e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[7.7679288e-01 2.8237467e-08]\n", + " [4.1188952e-01 4.0764037e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 693: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 694: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 695: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[1.2068622e-09 3.3267078e-01]\n", + " [3.4378329e-01 1.3908681e-10]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[2.3221710e-01 2.3198289e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 698: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 699: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 700: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [8.32404476e-05 7.58199811e-01]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 701: Predicted: [[7.563721e-01 3.619938e-07]\n", + " [6.241169e-01 6.246831e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 705: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 706: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 708: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 710: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 711: Predicted: [[8.6455115e-10 5.2697325e-01]\n", + " [5.1376015e-01 1.1751958e-10]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 712: Predicted: [[2.0908986e-01 2.2138101e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 713: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[3.6860154e-05 8.7357521e-01]\n", + " [8.7651759e-01 1.6234972e-08]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 715: Predicted: [[7.4616671e-01 7.5629568e-01]\n", + " [2.8692352e-06 8.1290174e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 716: Predicted: [[8.1086111e-01 3.8686110e-07]\n", + " [2.1933295e-01 2.2331314e-01]], True: [[0.375 0.375]\n", + " [0.125 0.125]]\n", + "Tile 717: Predicted: [[1.3820530e-05 6.4625037e-01]\n", + " [6.4509600e-01 3.6959753e-09]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 718: Predicted: [[5.3142864e-01 5.3549612e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 722: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 723: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 724: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 726: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 727: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 729: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 730: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 731: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 733: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 734: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 735: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[2.0722764e-14 2.3867948e-01]\n", + " [2.1451804e-01 3.6744344e-15]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[6.3496563e-03 7.1522058e-03]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 741: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 742: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 746: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 748: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 749: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 750: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 751: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 753: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 754: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 756: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 760: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 764: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 765: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 766: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 768: Predicted: [[1.0887209e-06 3.9254758e-01]\n", + " [3.8830581e-01 1.1486760e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[2.7755955e-01 2.7643132e-01]\n", + " [1.5340214e-04 6.3110137e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[6.2919605e-01 2.5609443e-08]\n", + " [4.9841124e-01 4.9835378e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 771: Predicted: [[6.1575328e-08 1.4452437e-01]\n", + " [1.3932042e-01 2.5552364e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[1.0139176e-03 1.3294612e-03]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [1.87699118e-06 7.89468110e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[7.7641189e-01 3.8470510e-08]\n", + " [3.0734834e-01 3.1116503e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 777: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 778: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 779: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 780: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 781: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [8.20731572e-08 6.44362450e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[6.3973945e-01 1.5318038e-07]\n", + " [2.7529553e-03 3.6644554e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 786: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 788: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 789: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 790: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 792: Predicted: [[3.9296014e-05 5.0045383e-01]\n", + " [5.0476581e-01 9.7902750e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 793: Predicted: [[3.9037213e-01 3.9609244e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 795: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 796: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 797: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 798: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 799: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 801: Predicted: [[1.2309054e-08 5.7324374e-01]\n", + " [5.6298476e-01 1.3622407e-09]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 802: Predicted: [[2.4575828e-01 2.5528470e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 805: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 806: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 807: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 808: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 809: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 819: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 820: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 823: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.08052438e-06 8.33612204e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 824: Predicted: [[8.2893610e-01 5.1539507e-07]\n", + " [1.4522424e-01 1.4597560e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 825: Predicted: [[4.4731028e-06 5.0683141e-01]\n", + " [5.1103890e-01 3.5968331e-08]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[3.8468999e-01 3.8599840e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 829: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [7.37007213e-07 3.90223861e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 830: Predicted: [[3.9261666e-01 4.2521297e-08]\n", + " [2.4620725e-01 2.5804624e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 832: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[3.9366669e-06 3.6471435e-01]\n", + " [3.6764702e-01 8.3499987e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[2.4688776e-01 2.4770491e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 836: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 838: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 839: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 840: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 841: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 843: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 844: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.5 0.375]\n", + " [0. 0. ]]\n", + "Tile 847: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [7.26262887e-12 4.91768181e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[4.8088557e-01 6.0646328e-13]\n", + " [1.9670875e-01 2.1210580e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 850: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 853: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 854: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 857: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 858: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 860: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 861: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 866: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 868: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 874: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [4.55086365e-06 8.64048123e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 875: Predicted: [[8.63592684e-01 1.18487556e-07]\n", + " [5.71708977e-01 5.60727715e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 876: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 878: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 879: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 880: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 883: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 885: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 886: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 887: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 888: Predicted: [[5.9488616e-07 4.6047726e-01]\n", + " [4.5707983e-01 4.7122927e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 889: Predicted: [[3.0952500e-02 3.3682883e-02]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[3.0757449e-06 3.7885469e-01]\n", + " [3.8046280e-01 5.0606019e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[2.5992185e-01 2.6098025e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 894: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 895: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 896: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 901: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[3.4712386e-07 6.7239910e-01]\n", + " [6.7632139e-01 2.7743997e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 904: Predicted: [[2.0300137e-02 2.3692770e-02]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[1.1891512e-04 7.6971763e-01]\n", + " [7.6765060e-01 2.5883540e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[6.0901910e-01 6.1132538e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 909: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 912: Predicted: [[1.6145657e-07 5.8691555e-01]\n", + " [5.9696883e-01 7.8932750e-08]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[4.4992249e-02 5.2104492e-02]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 917: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 918: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 919: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 920: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 921: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 922: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.37199333e-06 7.34891891e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 923: Predicted: [[7.32250810e-01 1.17922491e-06]\n", + " [1.05376780e-01 1.01459585e-01]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 924: Predicted: [[2.0173367e-08 6.5060735e-01]\n", + " [6.4748025e-01 3.3862784e-09]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[2.0833638e-01 2.2642711e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 928: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 930: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 935: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 937: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 938: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 941: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 942: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 944: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 948: Predicted: [[6.0150225e-11 3.3475968e-01]\n", + " [3.4950954e-01 2.7858349e-11]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 949: Predicted: [[9.3499338e-03 1.5233685e-02]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 951: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 953: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 954: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 956: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 957: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 959: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 962: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 964: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 965: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 966: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 967: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 969: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 970: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 974: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[5.8949786e-06 8.6770517e-01]\n", + " [8.6295998e-01 4.6861558e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 976: Predicted: [[4.1229504e-01 4.0030754e-01]\n", + " [2.4488434e-06 7.3883587e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 978: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 979: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 980: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 982: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 984: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 987: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 988: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 992: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.75206924e-09 3.37161124e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 995: Predicted: [[3.4446731e-01 3.4443295e-10]\n", + " [2.3704320e-01 2.3686489e-01]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 996: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1001: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 1002: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1004: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.25 0.375]\n", + " [0. 0. ]]\n", + "Tile 1005: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1006: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0.625 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 1008: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1009: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1012: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1014: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1015: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1016: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1017: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1019: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1020: Predicted: [[2.4488434e-06 7.3883587e-01]\n", + " [7.3644400e-01 1.1966157e-06]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1021: Predicted: [[1.08860366e-01 1.04586542e-01]\n", + " [2.44884336e-06 7.38835871e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1022: Predicted: [[7.36443996e-01 1.19661570e-06]\n", + " [1.08860366e-01 1.04586542e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1023: Predicted: [[9.689696e-07 4.810233e-01]\n", + " [4.786343e-01 8.891587e-07]], True: [[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "image_index = np.random.randint(0, 20) # Randomly pick an image in the batch\n", + "# image_index = 0\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def visualize_predictions_on_image(predicted_centers, true_centers, tile_size=8):\n", + " \"\"\"\n", + " Visualizes predictions and ground truth on the entire image.\n", + "\n", + " Args:\n", + " - predicted_centers: Predictions for the image (1024 tiles, max_hits, 2).\n", + " - true_centers: Ground truth centers for the image (1024 tiles, max_hits, 2).\n", + " - tile_size: Size of each tile.\n", + " \"\"\"\n", + " # Create a blank canvas for the image\n", + " image_size = int(np.sqrt(len(predicted_centers))) * tile_size\n", + " plt.figure(figsize=(10, 10))\n", + " plt.xlim(0, image_size)\n", + " plt.ylim(0, image_size)\n", + " plt.gca().invert_yaxis()\n", + "\n", + " # Iterate through each tile and plot predictions/ground truth\n", + " num_tiles_per_row = int(np.sqrt(len(predicted_centers)))\n", + " for tile_idx, (pred, true) in enumerate(zip(predicted_centers, true_centers)):\n", + " tile_row = tile_idx // num_tiles_per_row\n", + " tile_col = tile_idx % num_tiles_per_row\n", + "\n", + " # Plot predictions\n", + " for pred_hit in pred:\n", + " x, y = pred_hit\n", + " if x > 0.1 and y > 0.1: # Ignore no-object cases\n", + " plt.plot(x + tile_col * tile_size, y + tile_row * tile_size, 'ro', label=\"Prediction\")\n", + "\n", + " # Plot ground truth\n", + " for true_hit in true:\n", + " x, y = true_hit\n", + " if x > 0 and y > 0: # Ignore no-object cases\n", + " plt.plot(x + tile_col * tile_size, y + tile_row * tile_size, 'go', label=\"Ground Truth\")\n", + "\n", + " plt.title(\"Predictions vs Ground Truth\")\n", + " plt.legend([\"Prediction\", \"Ground Truth\"])\n", + " plt.show()\n", + "\n", + "# Visualize predictions for the selected image\n", + "visualize_predictions_on_image(predicted_image, true_targets_image, tile_size=8)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 48\n", + "False Positives (FP): 152\n", + "False Negatives (FN): 81\n", + "Precision: 0.2400, Recall: 0.3721\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "\n", + "threshold = 0.8 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits): \n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1* tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 99\n", + "False Positives (FP): 16\n", + "False Negatives (FN): 0\n", + "Precision: 0.8609, Recall: 1.0000\n" + ] + } + ], + "source": [ + "\n", + "\n", + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.8\n", + "tile_size = 8\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " matched_true_hits = set()\n", + " matched_predictions = set()\n", + "\n", + " for pred_idx, pred in enumerate(valid_predicted_hits):\n", + " if pred_idx in matched_predictions:\n", + " continue\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1 *tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " matched_predictions.add(pred_idx)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# # Example usage\n", + "# tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "# reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# # Plotting\n", + "# fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "# for i in range(4):\n", + "# ax[i].imshow(tiles[i], cmap='gray')\n", + "# ax[i].set_title(f\"Tile {i}\")\n", + "# ax[i].axis('off')\n", + "\n", + "# ax[4].imshow(reconstructed_image, cmap='gray')\n", + "# ax[4].set_title(\"Reconstructed Image\")\n", + "# ax[4].axis('off')\n", + "\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.8):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "c = np.random.randint(0,20)\n", + "image_index = c # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First image's first tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n", + "First image's second tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "for val_images, val_centers in val_dataset.take(1):\n", + " print(\"First image's first tile:\")\n", + " print(val_images[2, 0]) # Tile 0 of Image 0\n", + " print(\"First image's second tile:\")\n", + " print(val_images[2, 1]) # Tile 1 of Image 0\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/Solving Tiling Problem fo Hungarian Loss.ipynb b/Computer Vision_Object Detection/Solving Tiling Problem fo Hungarian Loss.ipynb new file mode 100644 index 0000000..e9a446a --- /dev/null +++ b/Computer Vision_Object Detection/Solving Tiling Problem fo Hungarian Loss.ipynb @@ -0,0 +1,1941 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:15:34.317436: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-22 15:15:34.329146: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-22 15:15:34.341470: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-22 15:15:34.345189: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-22 15:15:34.355430: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-22 15:15:34.996022: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:15:36.199604: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"]) \n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import tensorflow as tf\n", + "# from tensorflow.keras import layers, Model\n", + "# from sklearn.model_selection import train_test_split\n", + "# import h5py\n", + "\n", + "# class DataLoader:\n", + "# def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + "# self.h5_filename = h5_filename\n", + "# self.tile_size = tile_size\n", + "# self.max_hits_per_tile = max_hits_per_tile\n", + "# self.images, self.centers = self.load_data()\n", + "\n", + "# def load_data(self):\n", + "# with h5py.File(self.h5_filename, 'r') as f:\n", + "# images = np.array(f['images'])\n", + "# centers = np.array(f['centers_training'])\n", + "# return images, centers\n", + "\n", + "# def tile_image(self, image):\n", + "# tiles = []\n", + "# for i in range(0, image.shape[0], self.tile_size):\n", + "# for j in range(0, image.shape[1], self.tile_size):\n", + "# tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + "# tiles.append(tile)\n", + "# return np.array(tiles)\n", + "\n", + "# def map_hits_to_tiles(self, image, centers):\n", + "# tiles = self.tile_image(image)\n", + "# hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + "# for hit in centers:\n", + "# _, x, y = hit\n", + "# tile_row = int(y // self.tile_size)\n", + "# tile_col = int(x // self.tile_size)\n", + "# tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + "# local_x = x % self.tile_size\n", + "# local_y = y % self.tile_size\n", + "# hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + "# return tiles, hits_per_tile\n", + "\n", + "# def process_data(self):\n", + "# tiled_images = []\n", + "# tiled_centers = []\n", + "\n", + "# for img_idx in range(len(self.images)):\n", + "# image = self.images[img_idx]\n", + "# centers = self.centers[img_idx]\n", + "# tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + "# tiled_images.append(tiles)\n", + "\n", + "# tile_hits_list = [\n", + "# hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + "# for i in range(len(tiles))\n", + "# ]\n", + "# tiled_centers.append(tile_hits_list)\n", + "\n", + "# return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + "# def normalize_data(self):\n", + "# tiled_images, tiled_centers = self.process_data()\n", + "# normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + "# # Adjust the representation to include a \"presence\" flag\n", + "# normalized_centers = []\n", + "# for image in tiled_centers:\n", + "# adjusted_image = []\n", + "# for tile in image:\n", + "# adjusted_tile = []\n", + "# for x, y in tile:\n", + "# if (x, y) == (0, 0): # No object\n", + "# adjusted_tile.append([0, 0, 0]) # [presence, x, y]\n", + "# else: # Object\n", + "# adjusted_tile.append([1, x / self.tile_size, y / self.tile_size])\n", + "# adjusted_image.append(adjusted_tile)\n", + "# normalized_centers.append(adjusted_image)\n", + "\n", + "# return normalized_images, np.array(normalized_centers)\n", + "\n", + "# def create_datasets(data_loader, train_size=0.95):\n", + "# # Normalize data\n", + "# normalized_images, normalized_centers = data_loader.normalize_data()\n", + "# train_images, val_images, train_centers, val_centers = train_test_split(\n", + "# normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + "# )\n", + "\n", + "# # Flatten tiles for individual input to the model\n", + "# train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "\n", + "# train_centers_flat = train_centers.reshape(-1, 2, 3) # Adjusted to include [presence, x, y]\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 3)\n", + "\n", + "# # Create TensorFlow datasets\n", + "# batch_size = 2048*20\n", + "# train_dataset = (\n", + "# tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat))\n", + "# .batch(batch_size)\n", + "# .cache()\n", + "# .prefetch(tf.data.AUTOTUNE)\n", + "# )\n", + "# val_dataset = (\n", + "# tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat))\n", + "# .batch(batch_size)\n", + "# .cache()\n", + "# .prefetch(tf.data.AUTOTUNE)\n", + "# )\n", + "\n", + "# return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " # Load the dataset from the HDF5 file\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " \"\"\"\n", + " Split an image into non-overlapping tiles of size (tile_size x tile_size).\n", + " \"\"\"\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " \"\"\"\n", + " Map hit coordinates to corresponding tiles.\n", + " \"\"\"\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " # Calculate the tile index\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " # Map the hit to local tile coordinates\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " \"\"\"\n", + " Process all images and map hits to their corresponding tiles.\n", + " \"\"\"\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + "\n", + " # Store tiles\n", + " tiled_images.append(tiles)\n", + "\n", + " # Limit hits per tile and pad if necessary\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def add_presence_column(self, tiled_centers):\n", + " \"\"\"\n", + " Add a presence column to the tiled centers.\n", + " \"\"\"\n", + " centers_with_presence = []\n", + " for image_centers in tiled_centers:\n", + " image_with_presence = [\n", + " [(1.0 if (x != 0 or y != 0) else 0.0, x, y) for (x, y) in tile]\n", + " for tile in image_centers\n", + " ]\n", + " centers_with_presence.append(image_with_presence)\n", + " return np.array(centers_with_presence)\n", + "\n", + " def normalize_data(self):\n", + " \"\"\"\n", + " Normalize images and hits.\n", + " \"\"\"\n", + " tiled_images, tiled_centers = self.process_data()\n", + " # Add presence column\n", + " tiled_centers = self.add_presence_column(tiled_centers)\n", + "\n", + " # Normalize image pixel values\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + "\n", + " # Normalize hit coordinates to [0, 1]\n", + " normalized_centers = [[[(prob, x / self.tile_size, y / self.tile_size) for (prob, x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + " \n", + "def map_to_grid(centers, tile_size, grid_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Map hit centers to an 8x8 grid format.\n", + "\n", + " Args:\n", + " - centers: (num_samples, variable-length list of tuples) containing (prob, cx, cy).\n", + " - tile_size: Size of each tile.\n", + " - grid_size: Number of tiles along each dimension.\n", + " - max_hits_per_tile: Maximum number of hits per tile.\n", + "\n", + " Returns:\n", + " - grid_probs: (num_samples, grid_size, grid_size, 1) probabilities for each tile.\n", + " - grid_boxes: (num_samples, grid_size, grid_size, 2) bounding box midpoints for each tile.\n", + " \"\"\"\n", + " num_samples = len(centers)\n", + " grid_probs = np.zeros((num_samples, grid_size, grid_size, 1), dtype=np.float32)\n", + " grid_boxes = np.zeros((num_samples, grid_size, grid_size, 2), dtype=np.float32)\n", + "\n", + " for sample_idx, sample_centers in enumerate(centers):\n", + " for prob, cx, cy in sample_centers:\n", + " # Skip if probability is 0 (no hit)\n", + " if prob == 0:\n", + " continue\n", + "\n", + " # Compute grid indices\n", + " grid_x = int(cx * grid_size)\n", + " grid_y = int(cy * grid_size)\n", + "\n", + " # Ensure indices are within bounds\n", + " grid_x = min(grid_x, grid_size - 1)\n", + " grid_y = min(grid_y, grid_size - 1)\n", + "\n", + " # Set probability and normalized offsets\n", + " grid_probs[sample_idx, grid_y, grid_x, 0] = prob\n", + " grid_boxes[sample_idx, grid_y, grid_x, :] = [\n", + " (cx * grid_size) % 1, # Local x-offset within the grid cell\n", + " (cy * grid_size) % 1 # Local y-offset within the grid cell\n", + " ]\n", + "\n", + " return grid_probs, grid_boxes\n", + "\n", + "\n", + "def create_datasets(data_loader, train_size=0.95):\n", + " # Normalize images and centers\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " flat_images = normalized_images.reshape(-1, data_loader.tile_size, data_loader.tile_size, 1)\n", + " flat_centers = normalized_centers.reshape(-1, data_loader.max_hits_per_tile, 3) # Includes presence column\n", + "\n", + " # Extract probabilities and bounding boxes\n", + " flat_probs = np.array(flat_centers[..., 0:1]) # Slice the first column (presence/probability)\n", + " flat_boxes = np.array(flat_centers[..., 1:3]) # Slice the bounding box coordinates\n", + "\n", + " \n", + "\n", + " # Split into training and validation sets\n", + " train_images, val_images, train_probs, val_probs, train_boxes, val_boxes = train_test_split(\n", + " flat_images, flat_probs, flat_boxes, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Convert back to TensorFlow tensors after splitting\n", + " train_probs = tf.convert_to_tensor(train_probs, dtype=tf.float32)\n", + " train_probs = tf.expand_dims(train_probs, axis=1)\n", + " val_probs = tf.convert_to_tensor(val_probs, dtype=tf.float32)\n", + " val_probs = tf.expand_dims(val_probs, axis=1)\n", + " train_boxes = tf.convert_to_tensor(train_boxes, dtype=tf.float32)\n", + " train_boxes = tf.expand_dims(train_boxes, axis=1)\n", + " val_boxes = tf.convert_to_tensor(val_boxes, dtype=tf.float32)\n", + " val_boxes = tf.expand_dims(val_boxes, axis=1)\n", + "\n", + " # Create TensorFlow datasets with shuffling for the train dataset\n", + " train_dataset = tf.data.Dataset.from_tensor_slices(\n", + " (train_images, {'x_prob_reshape': train_probs, 'x_boxes_reshape': train_boxes})\n", + " ).shuffle(buffer_size=1024*200, reshuffle_each_iteration=True).batch(1024*200).cache().prefetch(tf.data.AUTOTUNE)\n", + "\n", + " val_dataset = tf.data.Dataset.from_tensor_slices(\n", + " (val_images, {'x_prob_reshape': val_probs, 'x_boxes_reshape': val_boxes})\n", + " ).batch(1024*200).cache().prefetch(tf.data.AUTOTUNE)\n", + "\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_probs, val_probs, train_boxes, val_boxes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# import numpy as np\n", + "# import tensorflow as tf\n", + "# from tensorflow.keras import layers, Model\n", + "# from sklearn.model_selection import train_test_split\n", + "# import h5py\n", + "\n", + "# class DataLoader:\n", + "# def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + "# self.h5_filename = h5_filename\n", + "# self.tile_size = tile_size\n", + "# self.max_hits_per_tile = max_hits_per_tile\n", + "# self.images, self.centers = self.load_data()\n", + "\n", + "# def load_data(self):\n", + "# with h5py.File(self.h5_filename, 'r') as f:\n", + "# images = np.array(f['images'])\n", + "# centers = np.array(f['centers_training'])\n", + "# return images, centers\n", + "\n", + "# def tile_image(self, image):\n", + "# tiles = []\n", + "# for i in range(0, image.shape[0], self.tile_size):\n", + "# for j in range(0, image.shape[1], self.tile_size):\n", + "# tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + "# tiles.append(tile)\n", + "# return np.array(tiles)\n", + "\n", + "# def map_hits_to_tiles(self, image, centers):\n", + "# tiles = self.tile_image(image)\n", + "# hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + "# for hit in centers:\n", + "# _, x, y = hit\n", + "# tile_row = int(y // self.tile_size)\n", + "# tile_col = int(x // self.tile_size)\n", + "# tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + "# local_x = x % self.tile_size\n", + "# local_y = y % self.tile_size\n", + "# hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + "# return tiles, hits_per_tile\n", + "\n", + "# def process_data(self):\n", + "# tiled_images = []\n", + "# tiled_centers = []\n", + "\n", + "# for img_idx in range(len(self.images)):\n", + "# image = self.images[img_idx]\n", + "# centers = self.centers[img_idx]\n", + "# tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + "# tiled_images.append(tiles)\n", + "\n", + "# tile_hits_list = [\n", + "# hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + "# for i in range(len(tiles))\n", + "# ]\n", + "# tiled_centers.append(tile_hits_list)\n", + "\n", + "# return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + "# def normalize_data(self):\n", + "# tiled_images, tiled_centers = self.process_data()\n", + "# normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + "# # Normalize coordinates to be within the range [0, 1]\n", + "# normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + "# for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + "# return normalized_images, np.array(normalized_centers)\n", + "\n", + "# def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + "# # Reshape images\n", + "# flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + "# # Ensure centers have the right shape and flatten them\n", + "# flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + "# return flat_images, flat_centers\n", + "\n", + "# def create_datasets(data_loader, train_size=0.95):\n", + "# # Normalize data\n", + "# normalized_images, normalized_centers = data_loader.normalize_data()\n", + "# train_images, val_images, train_centers, val_centers = train_test_split(\n", + "# normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + "# )\n", + "\n", + "# # Flatten tiles for individual input to the model\n", + "# train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "\n", + "# train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "# # Create TensorFlow datasets\n", + "# batch_size = 20480 * 20\n", + "# train_dataset = (\n", + "# tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat))\n", + "# .batch(batch_size)\n", + "# .cache()\n", + "# .prefetch(tf.data.AUTOTUNE)\n", + "# )\n", + "# val_dataset = (\n", + "# tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat))\n", + "# .batch(batch_size)\n", + "# .cache()\n", + "# .prefetch(tf.data.AUTOTUNE)\n", + "# )\n", + "\n", + "# return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/10KFixed_100_256by256_RandomindexNoNoise.h5'\n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images,train_probs,val_probs, train_boxes, val_boxes = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(TensorShape([9728000, 1, 2, 1]),\n", + " (9728000, 8, 8, 1),\n", + " TensorShape([512000, 1, 2, 1]),\n", + " (512000, 8, 8, 1),\n", + " <_PrefetchDataset element_spec=(TensorSpec(shape=(None, 8, 8, 1), dtype=tf.float64, name=None), {'x_prob_reshape': TensorSpec(shape=(None, 1, 2, 1), dtype=tf.float32, name=None), 'x_boxes_reshape': TensorSpec(shape=(None, 1, 2, 2), dtype=tf.float32, name=None)})>,\n", + " <_PrefetchDataset element_spec=(TensorSpec(shape=(None, 8, 8, 1), dtype=tf.float64, name=None), {'x_prob_reshape': TensorSpec(shape=(None, 1, 2, 1), dtype=tf.float32, name=None), 'x_boxes_reshape': TensorSpec(shape=(None, 1, 2, 2), dtype=tf.float32, name=None)})>,\n", + " TensorShape([9728000, 1, 2, 2]),\n", + " TensorShape([512000, 1, 2, 2]))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_probs.shape, train_images.shape, val_probs.shape, val_images.shape, train_dataset, val_dataset, train_boxes.shape, val_boxes.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch images shape: (204800, 8, 8, 1)\n", + "Batch x_prob shape: (204800, 1, 2, 1)\n", + "Batch x_boxes shape: (204800, 1, 2, 2)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-22 15:17:58.904342: W tensorflow/core/kernels/data/cache_dataset_ops.cc:913] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n", + "2025-01-22 15:17:59.006623: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" + ] + } + ], + "source": [ + "# Inspect dataset shapes\n", + "for images, labels in train_dataset.take(1):\n", + " print(\"Batch images shape:\", images.shape)\n", + " print(\"Batch x_prob shape:\", labels['x_prob_reshape'].shape)\n", + " print(\"Batch x_boxes shape:\", labels['x_boxes_reshape'].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(image, )\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.2)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.2)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,100)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras import layers, models\n", + "import tensorflow as tf\n", + "\n", + "\n", + "class GateLayer(layers.Layer):\n", + " def call(self, inputs):\n", + " x_prob, x_boxes = inputs\n", + " gate = tf.where(x_prob > 0.5, tf.ones_like(x_prob), tf.zeros_like(x_prob))\n", + " x_boxes = x_boxes * gate\n", + " \n", + " return x_prob, x_boxes\n", + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + " \n", + " x = layers.Conv2D(128, kernel_size=5, padding='same', activation='relu')(inputs)\n", + " x = layers.MaxPool2D()(x)\n", + " \n", + "\n", + " x = layers.Conv2D(64, kernel_size=5, padding='same', activation='relu')(x)\n", + " x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x)\n", + "\n", + " x = layers.Flatten()(x)\n", + " x = layers.Dense(128, activation='relu')(x)\n", + " x_prob = layers.Dense(max_hits, activation='sigmoid', name='x_prob')(x)\n", + " x_prob_reshape = layers.Reshape((-1, max_hits,1),name = 'x_prob_reshape')(x_prob)\n", + " x_boxes = layers.Dense(max_hits * 2,activation = 'sigmoid', name='x_boxes')(x)\n", + " x_boxes_reshape = layers.Reshape((-1,max_hits, 2),name = 'x_boxes_reshape')(x_boxes)\n", + " # x_prob = layers.Conv2D(1, kernel_size=3, padding='same', activation='sigmoid', name='x_prob')(x)\n", + " # x_boxes = layers.Conv2D(2, kernel_size=3, padding='same', name='x_boxes')(x)\n", + "\n", + " # Use GateLayer for processing (if applicable)\n", + " # x_prob, x_boxes = GateLayer()([x_prob, x_boxes])\n", + " \n", + "\n", + " # Define the model\n", + " model = tf.keras.models.Model(inputs, outputs=[x_prob_reshape, x_boxes_reshape])\n", + "\n", + " \n", + " \n", + "\n", + "\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((4864000, 8, 8, 1), (256000, 8, 8, 1), (4864000, 2, 1), (256000, 2, 1))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### no object loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)        ┃ Output Shape      ┃    Param # ┃ Connected to      ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer         │ (None, 8, 8, 1)   │          0 │ -                 │\n",
+       "│ (InputLayer)        │                   │            │                   │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ conv2d (Conv2D)     │ (None, 8, 8, 128) │      3,328 │ input_layer[0][0] │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ max_pooling2d       │ (None, 4, 4, 128) │          0 │ conv2d[0][0]      │\n",
+       "│ (MaxPooling2D)      │                   │            │                   │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ conv2d_1 (Conv2D)   │ (None, 4, 4, 64)  │    204,864 │ max_pooling2d[0]… │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ conv2d_2 (Conv2D)   │ (None, 4, 4, 64)  │     36,928 │ conv2d_1[0][0]    │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ flatten (Flatten)   │ (None, 1024)      │          0 │ conv2d_2[0][0]    │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ dense (Dense)       │ (None, 128)       │    131,200 │ flatten[0][0]     │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ x_prob (Dense)      │ (None, 2)         │        258 │ dense[0][0]       │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ x_boxes (Dense)     │ (None, 4)         │        516 │ dense[0][0]       │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ x_prob_reshape      │ (None, 1, 2, 1)   │          0 │ x_prob[0][0]      │\n",
+       "│ (Reshape)           │                   │            │                   │\n",
+       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
+       "│ x_boxes_reshape     │ (None, 1, 2, 2)   │          0 │ x_boxes[0][0]     │\n",
+       "│ (Reshape)           │                   │            │                   │\n",
+       "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n", + "│ input_layer │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", + "│ (\u001b[38;5;33mInputLayer\u001b[0m) │ │ │ │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m3,328\u001b[0m │ input_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ max_pooling2d │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ conv2d[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ │ │ │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m204,864\u001b[0m │ max_pooling2d[\u001b[38;5;34m0\u001b[0m]… │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m36,928\u001b[0m │ conv2d_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1024\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ conv2d_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m131,200\u001b[0m │ flatten[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ x_prob (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m258\u001b[0m │ dense[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ x_boxes (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │ dense[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ x_prob_reshape │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ x_prob[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │ │\n", + "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", + "│ x_boxes_reshape │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ x_boxes[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", + "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │ │\n", + "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 377,094 (1.44 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m377,094\u001b[0m (1.44 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 377,094 (1.44 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m377,094\u001b[0m (1.44 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " \n", + " model = create_model()\n", + " model.compile(\n", + " optimizer='adam',\n", + " loss= {'x_prob_reshape': tf.keras.losses.BinaryCrossentropy(), 'x_boxes_reshape':tf.keras.losses.MeanSquaredError()}\n", + " \n", + ")\n", + "\n", + "\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<_PrefetchDataset element_spec=(TensorSpec(shape=(None, 8, 8, 1), dtype=tf.float64, name=None), {'x_prob': TensorSpec(shape=(None, 2, 1), dtype=tf.float64, name=None), 'x_boxes': TensorSpec(shape=(None, 2, 2), dtype=tf.float64, name=None)})>" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-21 12:44:09.039593: W tensorflow/core/kernels/gpu_utils.cc:68] Failed to allocate memory for convolution redzone checking; skipping this check. This is benign and only means that we won't check cudnn for out-of-bounds reads and writes. This message will only be printed once.\n", + "2025-01-21 12:44:09.048582: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1737481449.107319 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.149198 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.153916 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.207089 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.218729 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.238870 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.238940 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.260222 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.291472 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.321656 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.360244 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.437803 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.546609 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.698663 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.712278 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.726099 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.748185 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.769672 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.791471 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.820497 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.841139 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.881024 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481449.928685 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481450.021402 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481450.093994 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481450.183500 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481450.260121 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481450.405348 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481450.551902 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.228497 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.257055 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.280618 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.305670 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.320873 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.348714 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.365055 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.381998 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.424850 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.449926 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.463798 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.478136 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.512041 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.533388 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.563447 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.649682 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.723555 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.736594 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.742905 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.749047 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.756540 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.769944 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.783920 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.797930 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.812175 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.831703 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.857541 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481451.883741 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.087585 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.095335 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.100685 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.117219 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.126180 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.182016 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.198169 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.204941 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.211310 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.215958 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.223314 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.228549 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.234856 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.245805 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.250990 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.259841 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.263763 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.268810 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.276150 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.282352 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.290052 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481452.310035 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.673323 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.678636 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.684955 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.691559 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.698142 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.704214 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.711285 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.716313 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.721360 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.728594 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.737188 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.743086 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.752981 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.762765 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.776865 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.790887 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.804979 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.819021 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.832579 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.858326 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.890099 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.951861 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481453.985600 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.177325 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.182792 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.189033 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.194498 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.202703 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.209482 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.221190 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.228335 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.234842 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.241718 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.249227 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.256255 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.264970 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.273621 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.329436 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.350880 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.361409 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.370979 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.380490 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.386978 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.393369 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.399802 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.409909 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.419681 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.429962 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.439888 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.449829 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.460013 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.470728 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.478749 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.487996 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.512236 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.525068 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.841700 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.849526 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.856152 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.875624 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.889683 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.900943 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.909308 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.921777 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.945130 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.967864 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481454.992190 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.025726 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.082056 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.112944 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.137824 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.163581 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.189296 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.215359 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.241712 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.266407 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.295070 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.323703 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.348357 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.371900 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.401566 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.431341 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.454753 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.476729 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.498529 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.529493 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.553324 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.586469 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.617332 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.648126 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481455.770105 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.482734 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.511430 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.536254 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.562078 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.614410 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.642904 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.674156 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.711509 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.742933 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.861764 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.896465 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481457.940917 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.159298 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.283257 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.297177 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.310174 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.324063 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.339152 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.355451 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.369368 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.392285 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.405384 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.419113 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.441698 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.455947 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.471600 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.489728 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.505280 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.525298 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.619611 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481458.712772 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481459.878766 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481459.892594 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481459.908658 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481459.922531 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481459.940859 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481459.959550 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481459.974112 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481459.989448 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.017208 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.033605 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.051903 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.075027 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.096361 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.116634 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.167057 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.252608 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.282834 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.328744 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.359149 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.386367 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.419394 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.433234 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.433310 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.474648 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481460.527526 1048714 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m47/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m1s\u001b[0m 1s/step - loss: 0.5946" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-21 12:45:21.963798: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "W0000 00:00:1737481521.976231 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481521.980701 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481521.980807 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481521.987854 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481521.993662 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.003964 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.004038 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.014884 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.040688 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.056496 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.086131 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.101049 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.120178 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.158868 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.213147 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.252318 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.266850 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.273912 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.285244 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.296627 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.308161 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.323519 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.334367 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.355158 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.379681 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.416493 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.461900 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.508837 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.547414 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.620178 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481522.690737 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.029567 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.043972 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.055866 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.068451 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.076374 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.090763 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.099395 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.108243 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.118815 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.132143 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.139617 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.147349 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.165688 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.177399 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.193573 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.238618 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.279196 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.283364 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.286667 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.289873 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.293781 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.300822 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.308152 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.315515 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.323020 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.333003 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.346322 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.359795 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.463032 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.467037 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.469816 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.478157 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.482739 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.510758 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.518933 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.522181 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.525477 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.527935 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.531700 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.534419 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.537727 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.543390 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.546121 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.550688 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.552791 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.555452 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.559295 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.562576 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.566613 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.577010 1048712 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.612969 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.616454 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.619143 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.622364 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.625612 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.628862 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.632300 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.635005 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.637648 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.641414 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.645857 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.648940 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.654038 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.659067 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.666451 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.673787 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.681132 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.688423 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.695443 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.708553 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.724095 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.753422 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.770564 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.859819 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.862671 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.865326 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.868185 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.871079 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.874580 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.880576 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.884328 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.887705 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.891309 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.895229 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.898891 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.903220 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.907834 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.937048 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.946778 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.952200 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.957164 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.962137 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.967197 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.972277 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.975666 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.979062 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.982484 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.987762 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.992948 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481523.998128 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.003387 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.008948 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.013161 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.017969 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.030345 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.036867 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.201224 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.205543 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.209126 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.219792 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.227119 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.233051 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.237481 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.243942 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.255862 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.267594 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.279474 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.296528 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.326279 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.341087 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.353882 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.367081 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.380496 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.393568 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.406900 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.419183 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.433789 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.446125 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.460755 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.472658 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.484547 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.499767 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.510892 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.526118 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.537319 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.553314 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.569968 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.582029 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.597660 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.613311 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481524.675104 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.565484 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.581355 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.594610 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.607302 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.634065 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.648521 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.666585 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.685481 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.705707 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.765696 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.783230 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.805577 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.914921 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.966741 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.980999 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.987704 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481525.994880 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.002821 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.011402 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.019056 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.031473 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.038622 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.046069 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.058270 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.065969 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.074440 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.082846 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.092776 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.103529 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.152719 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.200057 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.783979 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.791035 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.799180 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.806271 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.815920 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.825821 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.833757 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.842121 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.857041 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.865926 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.875760 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.888156 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.899567 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.910359 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.929742 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.980791 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481526.996184 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481527.019470 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481527.034919 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481527.048747 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481527.065544 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481527.072672 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481527.072729 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481527.093774 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481527.118971 1048715 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1s/step - loss: 0.5897" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737481528.042770 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.055643 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.068547 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.084601 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.100662 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.112814 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.125924 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.139530 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.152024 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.163630 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.175046 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.188699 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.205609 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.224996 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.249847 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.267852 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.291202 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.318147 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.341507 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.368050 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.384838 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.408131 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.490884 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.496397 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.504764 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.534742 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.555626 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.592958 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.643571 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.768359 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.865292 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.878386 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.893284 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.916277 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.938431 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.954802 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481528.974406 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481529.135272 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481529.287879 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481529.474675 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481529.654879 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481529.984379 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.360550 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.373969 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.386941 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.402973 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.429113 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.455646 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.472485 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.492393 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.527027 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.550304 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.571845 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.602337 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.666071 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.758312 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.771487 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.777072 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.782393 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.786659 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.791220 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.796556 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.832538 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.866473 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.902675 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.933034 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481531.970616 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.034658 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.368454 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.373931 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.379234 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.383181 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.389533 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.393786 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.401902 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.408432 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.418713 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.426345 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.435436 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.443492 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.462318 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.467691 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.472871 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.479338 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.486250 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.503990 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.563024 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.576677 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "2025-01-21 12:45:32.869782: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "W0000 00:00:1737481532.873737 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.880957 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.888014 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.896400 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.904769 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.911086 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.917161 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.923152 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.929988 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.936444 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.942309 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.949244 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.957642 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.969910 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.980492 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481532.990296 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.002090 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.015726 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.029171 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.037732 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.049608 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.061431 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.102866 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.105620 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.110037 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.138426 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.153624 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.164527 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.183374 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.209021 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.267230 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.307011 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.321698 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.329260 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.340080 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.350743 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.358800 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.368328 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.449806 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.526892 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.620686 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.711117 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481533.876404 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.564823 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.571667 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.578280 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.585967 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.598348 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.611603 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.620139 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.630095 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.647515 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.659308 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.670198 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.685642 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.719289 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.770165 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.774571 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.776753 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.779571 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.782275 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.784594 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.787220 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.804575 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.821700 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.839902 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.855166 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.873375 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481534.905834 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m89s\u001b[0m 2s/step - loss: 0.5851 - val_loss: 0.1154 - learning_rate: 0.0010\n", + "Epoch 2/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737481535.073905 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.076766 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.079529 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.081521 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.084803 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.087033 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.091150 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.094441 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.099510 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.103364 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.107944 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.112039 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.121468 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.124240 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.126907 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.130231 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.133747 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.142601 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.172454 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737481535.179479 1048713 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 293ms/step - loss: 0.0646 - val_loss: 0.0356 - learning_rate: 0.0010\n", + "Epoch 3/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-21 12:45:51.125074: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 237ms/step - loss: 0.0346 - val_loss: 0.0331 - learning_rate: 0.0010\n", + "Epoch 4/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 240ms/step - loss: 0.0325 - val_loss: 0.0311 - learning_rate: 0.0010\n", + "Epoch 5/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-21 12:46:15.889130: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 256ms/step - loss: 0.0306 - val_loss: 0.0302 - learning_rate: 0.0010\n", + "Epoch 6/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 259ms/step - loss: 0.0294 - val_loss: 0.0288 - learning_rate: 0.0010\n", + "Epoch 7/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 234ms/step - loss: 0.0285 - val_loss: 0.0284 - learning_rate: 0.0010\n", + "Epoch 8/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 257ms/step - loss: 0.0280 - val_loss: 0.0280 - learning_rate: 0.0010\n", + "Epoch 9/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-21 12:47:06.347844: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 255ms/step - loss: 0.0279 - val_loss: 0.0281 - learning_rate: 0.0010\n", + "Epoch 10/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 280ms/step - loss: 0.0277 - val_loss: 0.0275 - learning_rate: 0.0010\n", + "Epoch 11/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 277ms/step - loss: 0.0273 - val_loss: 0.0278 - learning_rate: 0.0010\n", + "Epoch 12/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 279ms/step - loss: 0.0272 - val_loss: 0.0273 - learning_rate: 0.0010\n", + "Epoch 13/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 277ms/step - loss: 0.0270 - val_loss: 0.0270 - learning_rate: 0.0010\n", + "Epoch 14/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 305ms/step - loss: 0.0268 - val_loss: 0.0280 - learning_rate: 0.0010\n", + "Epoch 15/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 276ms/step - loss: 0.0273 - val_loss: 0.0266 - learning_rate: 0.0010\n", + "Epoch 16/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 267ms/step - loss: 0.0268 - val_loss: 0.0278 - learning_rate: 0.0010\n", + "Epoch 17/30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-21 12:49:03.175077: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 257ms/step - loss: 0.0270 - val_loss: 0.0265 - learning_rate: 0.0010\n", + "Epoch 18/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 246ms/step - loss: 0.0267 - val_loss: 0.0265 - learning_rate: 0.0010\n", + "Epoch 19/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 276ms/step - loss: 0.0262 - val_loss: 0.0264 - learning_rate: 0.0010\n", + "Epoch 20/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 234ms/step - loss: 0.0263 - val_loss: 0.0265 - learning_rate: 0.0010\n", + "Epoch 21/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 264ms/step - loss: 0.0264 - val_loss: 0.0262 - learning_rate: 0.0010\n", + "Epoch 22/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 258ms/step - loss: 0.0262 - val_loss: 0.0261 - learning_rate: 0.0010\n", + "Epoch 23/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 260ms/step - loss: 0.0263 - val_loss: 0.0265 - learning_rate: 0.0010\n", + "Epoch 24/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 254ms/step - loss: 0.0261 - val_loss: 0.0262 - learning_rate: 0.0010\n", + "Epoch 25/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 234ms/step - loss: 0.0261 - val_loss: 0.0267 - learning_rate: 0.0010\n", + "Epoch 26/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 255ms/step - loss: 0.0268 - val_loss: 0.0263 - learning_rate: 0.0010\n", + "Epoch 27/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 254ms/step - loss: 0.0259 - val_loss: 0.0258 - learning_rate: 0.0010\n", + "Epoch 28/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 235ms/step - loss: 0.0257 - val_loss: 0.0256 - learning_rate: 0.0010\n", + "Epoch 29/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 258ms/step - loss: 0.0257 - val_loss: 0.0259 - learning_rate: 0.0010\n", + "Epoch 30/30\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 235ms/step - loss: 0.0259 - val_loss: 0.0257 - learning_rate: 0.0010\n" + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=30,\n", + " \n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/Jan 21 weights/10KFixed_100_256by256_RandomindexNoNoise_2_heads.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "train_dataset = tf.data.Dataset.from_tensor_slices(\n", + " (train_images, {'x_prob_reshape': train_probs, 'x_boxes_reshape': train_boxes})\n", + " ).batch(2048)\n", + "inputs,targets = next(iter(train_dataset))\n", + "outputs = loaded_model(inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " )" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = np.random.randint(0,1000)\n", + "outputs[1][t],targets['x_boxes_reshape'][t]" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def visualize_midpoints(image, midpoints):\n", + " \"\"\"\n", + " Visualizes midpoints on an image without using a probability vector.\n", + "\n", + " Parameters:\n", + " - image: A 3D tensor representing the image.\n", + " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + "\n", + " Returns:\n", + " None (displays the image with midpoints).\n", + " \"\"\"\n", + " # Convert to NumPy arrays for easier handling\n", + " image_np = image\n", + " midpoints_np = midpoints\n", + "\n", + " # Denormalize image if necessary (adjust based on your normalization method)\n", + " denormalized_image = image_np # Modify if normalization was applied during training\n", + "\n", + " # Visualize the image\n", + " plt.figure(figsize=(4, 4))\n", + " plt.imshow(denormalized_image, cmap='gray')\n", + " plt.title(\"Predicted Midpoint Visualization\")\n", + "\n", + " # Plot midpoints directly\n", + " for i, (x, y) in enumerate(midpoints_np):\n", + " plt.scatter(x, y, color='red', s=5)\n", + "\n", + " plt.show()\n", + "\n", + "def visualize_midpoints2(image, midpoints):\n", + " \"\"\"\n", + " Visualizes ground truth midpoints on an image without using a probability vector.\n", + "\n", + " Parameters:\n", + " - image: A 3D tensor representing the image.\n", + " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + "\n", + " Returns:\n", + " None (displays the image with midpoints).\n", + " \"\"\"\n", + " # Convert to NumPy arrays for easier handling\n", + " image_np = image\n", + " midpoints_np = midpoints\n", + "\n", + " # Denormalize image if necessary (adjust based on your normalization method)\n", + " denormalized_image = image_np # Modify if normalization was applied during training\n", + "\n", + " # Visualize the image\n", + " plt.figure(figsize=(4, 4))\n", + " plt.imshow(denormalized_image, cmap='gray')\n", + " plt.title(\"Ground Truth Midpoint Visualization\")\n", + "\n", + " # Plot midpoints directly\n", + " for i, (x, y) in enumerate(midpoints_np):\n", + " plt.scatter(x, y, color='red', s=5)\n", + "\n", + " plt.show()\n", + "\n", + "# Example usage with random data\n", + "t = np.random.randint(0, 2048)\n", + "# t=5\n", + "\n", + "visualize_midpoints(inputs[t], outputs[1][t,0,:,:]*8)\n", + "visualize_midpoints2(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(targets['x_boxes_reshape'][t,0,:,:])*8)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/Jan 21 weights/10KFixed_100_256by256_RandomindexNoNoise_2_heads.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/Jan 21 weights/10KFixed_100_256by256_RandomindexNoNoise_2_heads.keras')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Computer Vision_Object Detection/Trained_Weights/10KFixed_100_256by256_RandomindexNoNoise_linear_separatelosses.png b/Computer Vision_Object Detection/Trained_Weights/10KFixed_100_256by256_RandomindexNoNoise_linear_separatelosses.png new file mode 100644 index 0000000..65b0265 Binary files /dev/null and b/Computer Vision_Object Detection/Trained_Weights/10KFixed_100_256by256_RandomindexNoNoise_linear_separatelosses.png differ diff --git a/Computer Vision_Object Detection/Using Objectness score.ipynb b/Computer Vision_Object Detection/Using Objectness score.ipynb new file mode 100644 index 0000000..ab67c2b --- /dev/null +++ b/Computer Vision_Object Detection/Using Objectness score.ipynb @@ -0,0 +1,6037 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 10:53:24.428474: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-20 10:53:24.440379: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-20 10:53:24.452502: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-20 10:53:24.456168: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-20 10:53:24.466466: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2025-01-20 10:53:25.086134: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-20 10:53:26.229700: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"]) \n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def create_datasets(data_loader, train_size=0.95):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + " val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "\n", + " train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + " val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + " # Create TensorFlow datasets\n", + " batch_size = 20480 * 20\n", + " train_dataset = (\n", + " tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat))\n", + " .batch(batch_size)\n", + " .cache()\n", + " .prefetch(tf.data.AUTOTUNE)\n", + " )\n", + " val_dataset = (\n", + " tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat))\n", + " .batch(batch_size)\n", + " .cache()\n", + " .prefetch(tf.data.AUTOTUNE)\n", + " )\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Computer Vision_Object Detection/Data/100Fixed_100_256by256_TestData_RandomindexNoNoise.h5'\n", + "\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0.25, 0.25],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]],\n", + "\n", + "\n", + " [[[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]],\n", + "\n", + " [[0. , 0. ],\n", + " [0. , 0. ]]]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# # After you load and normalize the data\n", + "# normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# # Flatten to tile-level\n", + "# num_images = normalized_centers.shape[0] # how many big images\n", + "# num_tiles = normalized_centers.shape[1] # tiles per image, e.g. 256*256 / (8*8) = 1024\n", + "# max_hits = normalized_centers.shape[3] # 2\n", + "# _ = normalized_centers.shape[3] # 2 coords\n", + "\n", + "# num_hits_distribution = {0: 0, 1: 0, 2: 0, 3: 0}\n", + "\n", + "# for i in range(num_images):\n", + "# for t in range(num_tiles):\n", + "# # Extract the 2 hits for tile t of image i\n", + "# tile_hits = normalized_centers[i, t] # shape (2,2)\n", + "# # Determine how many are nonzero\n", + "# row_nonzero = np.any(tile_hits != 0, axis=-1) # shape (2,)\n", + "# hits_count = np.sum(row_nonzero) # 0,1, or 2\n", + "# num_hits_distribution[hits_count] += 1\n", + "\n", + "# print(\"Distribution of hits across all tiles:\")\n", + "# for k in [0,1,2,3]:\n", + "# print(f\"{k} hits: {num_hits_distribution[k]}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# labels = list(num_hits_distribution.keys()) # [0, 1, 2]\n", + "# counts = list(num_hits_distribution.values()) # [count0, count1, count2]\n", + "\n", + "# plt.figure(figsize=(6, 4))\n", + "# plt.bar(labels, counts, color=['blue', 'red', 'green', 'purple'])\n", + "# plt.xticks(labels, ['0 hits', '1 hit', '2 hits', '3 hits'])\n", + "# plt.ylabel('Number of Tiles')\n", + "# plt.title('Distribution of Hits per Tile')\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(image, )\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.2)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.2)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,100)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " \"\"\"\n", + " Create a model that predicts hit locations for individual tiles.\n", + " \n", + " Parameters:\n", + " - input_shape: shape of the input tile (e.g., (8, 8, 1)).\n", + " - max_hits: maximum number of hits per tile (e.g., 2).\n", + "\n", + " Returns:\n", + " - model: The Keras model.\n", + " \"\"\"\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional and pooling layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + "\n", + " # Now each slot has 3 channels: [presence, x, y]\n", + " outputs = layers.Dense(2 * 2, activation='linear')(x) \n", + " outputs = layers.Reshape((2, 2))(outputs) \n", + "\n", + "\n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((9500, 1024, 8, 8), (500, 1024, 8, 8), (9500, 1024, 2, 2), (500, 1024, 2, 2))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Check out this loss function AGAIN" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def split_mean_loss(y_true, y_pred):\n", + "# \"\"\"\n", + "# Custom loss function to separately calculate the loss for tiles with hits\n", + "# and empty tiles, explicitly comparing predictions to the GT for empty tiles.\n", + "# \"\"\"\n", + "# # Create a mask for tiles with hits (non-empty tiles)\n", + "# valid_mask = tf.reduce_any(y_true != 0, axis=-1, keepdims=True) # Shape: (batch_size, max_hits, 1)\n", + "\n", + "# # Loss for tiles with hits (valid tiles)\n", + "# valid_loss = tf.square(y_true - y_pred) * tf.cast(valid_mask, dtype=y_true.dtype)\n", + "# mean_valid_loss = tf.reduce_mean(valid_loss) # Mean loss over tiles with hits\n", + "\n", + "# # Loss for empty tiles (explicitly comparing predictions to y_true)\n", + "# empty_loss = tf.square(y_true - y_pred) * tf.cast(~valid_mask, dtype=y_pred.dtype)\n", + "# mean_empty_loss = tf.reduce_mean(empty_loss) # Mean loss over empty tiles\n", + "\n", + "# # Combine the two losses\n", + "# total_loss = mean_valid_loss + mean_empty_loss\n", + "\n", + "# return total_loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def refined_detection_loss_with_padding(y_true, y_pred):\n", + "# \"\"\"\n", + "# Custom loss function accounting for:\n", + "# - Valid hits (ignoring padding (0, 0)).\n", + "# - Empty tiles (penalizing false positives).\n", + "# \"\"\"\n", + "# # Create masks\n", + "# valid_mask = tf.reduce_any(y_true != 0, axis=-1, keepdims=True) # Non-empty tiles\n", + "# padding_mask = tf.reduce_all(y_true == 0, axis=-1, keepdims=True) # Identify padding entries\n", + "\n", + "# # Cast boolean masks to float32\n", + "# valid_mask_float = tf.cast(valid_mask, dtype=y_true.dtype)\n", + "# padding_mask_float = tf.cast(padding_mask, dtype=y_true.dtype)\n", + "\n", + "# # ========================\n", + "# # Loss for Tiles with Hits\n", + "# # ========================\n", + "# # Exclude padding (0, 0) in valid tiles\n", + "# valid_loss = tf.square(y_true - y_pred) * valid_mask_float * (1 - padding_mask_float)\n", + "# mean_valid_loss = tf.reduce_sum(valid_loss) / (tf.reduce_sum(valid_mask_float * (1 - padding_mask_float)) + 1e-6)\n", + "\n", + "# # =============================\n", + "# # Loss for Empty Tiles (No Hits)\n", + "# # =============================\n", + "# # Compare predictions to (0, 0) for empty tiles\n", + "# empty_target = tf.zeros_like(y_true) # Ground truth for empty tiles is (0, 0)\n", + "# empty_loss = tf.square(y_pred - empty_target) * padding_mask_float\n", + "# mean_empty_loss = tf.reduce_sum(empty_loss) / (tf.reduce_sum(padding_mask_float) + 1e-6)\n", + "\n", + "# # ========================\n", + "# # Combine the Two Losses\n", + "# # ========================\n", + "# valid_weight = 1.0 # Weight for valid tiles\n", + "# no_object_weight = 3.0 # Weight for empty tiles\n", + "\n", + "# total_loss = valid_weight * mean_valid_loss + no_object_weight * mean_empty_loss\n", + "\n", + "# return total_loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def hungarian_loss_for_two_hits_vectorized(y_true, y_pred,\n", + "# w_0=1.0,\n", + "# w_1=1.0,\n", + "# w_2=1.0):\n", + "# \"\"\"\n", + "# Returns:\n", + "# total_loss (scalar),\n", + "# debug_info (dict with partial losses and tile counts)\n", + "# \"\"\"\n", + "# # Force both inputs to float32\n", + "# y_true = tf.cast(y_true, tf.float32)\n", + "# y_pred = tf.cast(y_pred, tf.float32)\n", + "# row_nonzero = tf.reduce_any(tf.not_equal(y_true, 0.0), axis=-1) # (batch, 2)\n", + "# num_hits = tf.reduce_sum(tf.cast(row_nonzero, tf.float32), axis=-1) # (batch,)\n", + " \n", + "# # Masks\n", + "# mask_0 = tf.equal(num_hits, 0.0) \n", + "# mask_1 = tf.equal(num_hits, 1.0)\n", + "# mask_2 = tf.equal(num_hits, 2.0)\n", + "# mask_0_f = tf.cast(mask_0, tf.float32)\n", + "# mask_1_f = tf.cast(mask_1, tf.float32)\n", + "# mask_2_f = tf.cast(mask_2, tf.float32)\n", + "\n", + "# # ---------------- 0 hits cost ----------------\n", + "# cost0 = tf.reduce_sum(tf.square(y_pred), axis=[1, 2]) # (batch,)\n", + "\n", + "# # ---------------- 2 hits cost (hungarian) ----------------\n", + "# dist_1_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 0, :]), axis=-1)\n", + "# dist_1_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 1, :]), axis=-1)\n", + "# cost_1 = dist_1_1 + dist_1_2\n", + "\n", + "# dist_2_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 1, :]), axis=-1)\n", + "# dist_2_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 0, :]), axis=-1)\n", + "# cost_2 = dist_2_1 + dist_2_2\n", + "\n", + "# cost2 = tf.minimum(cost_1, cost_2) # (batch,)\n", + "\n", + "# # ---------------- 1 hit cost ----------------\n", + "# row0_is_hit = row_nonzero[:, 0]\n", + "# gt_hit = tf.where(\n", + "# tf.expand_dims(row0_is_hit, axis=-1),\n", + "# y_true[:, 0, :],\n", + "# y_true[:, 1, :]\n", + "# )\n", + "# dist_pred_0 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 0, :]), axis=-1)\n", + "# dist_pred_1 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 1, :]), axis=-1)\n", + "\n", + "# zero_cost_0 = tf.reduce_sum(tf.square(y_pred[:, 0, :]), axis=-1)\n", + "# zero_cost_1 = tf.reduce_sum(tf.square(y_pred[:, 1, :]), axis=-1)\n", + "\n", + "# cost_if_0_matched = dist_pred_0 + zero_cost_1\n", + "# cost_if_1_matched = dist_pred_1 + zero_cost_0\n", + "# cost1 = tf.minimum(cost_if_0_matched, cost_if_1_matched) # (batch,)\n", + "# # row0_is_hit = row_nonzero[:, 0]\n", + "# # gt_hit = tf.where(\n", + "# # tf.expand_dims(row0_is_hit, axis=-1),\n", + "# # y_true[:, 0, :],\n", + "# # y_true[:, 1, :]\n", + "# # )\n", + "# # dist_pred_0 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 0, :]), axis=-1)\n", + "# # zero_cost_1 = tf.reduce_sum(tf.square(y_pred[:, 1, :]), axis=-1)\n", + "# # cost1 = dist_pred_0 + zero_cost_1\n", + "\n", + "# # ---------------- weights ----------------\n", + "# weighted_cost_0 = w_0 * cost0\n", + "# weighted_cost_1 = w_1 * cost1\n", + "# weighted_cost_2 = w_2 * cost2\n", + "\n", + "# # ---------------- combine ----------------\n", + "# total_cost = (mask_0_f * weighted_cost_0 +\n", + "# mask_1_f * weighted_cost_1 +\n", + "# mask_2_f * weighted_cost_2)\n", + "\n", + "# loss = tf.reduce_mean(total_cost)\n", + "\n", + "# # ---------------- partial losses for debugging ----------------\n", + "# eps = 0\n", + "# num0 = tf.reduce_sum(mask_0_f) \n", + "# num1 = tf.reduce_sum(mask_1_f)\n", + "# num2 = tf.reduce_sum(mask_2_f)\n", + "\n", + "# avg_cost0 = tf.reduce_sum(mask_0_f * cost0) / (num0 + eps)\n", + "# avg_cost1 = tf.reduce_sum(mask_1_f * cost1) / (num1 + eps)\n", + "# avg_cost2 = tf.reduce_sum(mask_2_f * cost2) / (num2 + eps)\n", + "\n", + "# debug_info = {\n", + "# \"avg_cost0\": avg_cost0,\n", + "# \"avg_cost1\": avg_cost1,\n", + "# \"avg_cost2\": avg_cost2,\n", + "# \"num0\": num0,\n", + "# \"num1\": num1,\n", + "# \"num2\": num2,\n", + "# }\n", + "\n", + "# return loss, debug_info\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def hungarian_loss_for_two_hits_vectorized(y_true, y_pred):\n", + "# \"\"\"\n", + "# Permutation-invariant loss for a tile with up to 2 hits, vectorized version.\n", + " \n", + "# y_true, y_pred: (batch_size, 2, 2)\n", + "# - y_true[i] has up to 2 hits, with zero-padding for empty slots.\n", + "# - y_pred[i] is the model's 2 predicted points.\n", + "# Returns: scalar (averaged loss across the batch).\n", + "# \"\"\"\n", + "\n", + "# # 1) Identify how many hits per tile\n", + "# # row_nonzero[i,j] = True if y_true[i,j] != (0,0)\n", + "# row_nonzero = tf.reduce_any(tf.not_equal(y_true, 0.0), axis=-1) # (batch_size, 2)\n", + "# num_hits = tf.reduce_sum(tf.cast(row_nonzero, tf.float32), axis=-1) # (batch_size,), values ∈ {0,1,2}\n", + "\n", + "# # 2) Create masks for 0-hit, 1-hit, 2-hit tiles\n", + "# mask_0 = tf.equal(num_hits, 0.0) # (batch_size,)\n", + "# mask_1 = tf.equal(num_hits, 1.0) # (batch_size,)\n", + "# mask_2 = tf.equal(num_hits, 2.0) # (batch_size,)\n", + "\n", + "# mask_0_f = tf.cast(mask_0, tf.float32)\n", + "# mask_1_f = tf.cast(mask_1, tf.float32)\n", + "# mask_2_f = tf.cast(mask_2, tf.float32)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 0 HITS: Force both predicted points to be (0,0).\n", + "# # -------------------------------------------------------------------------\n", + "# # cost0[i] = sum of squares of y_pred[i], i.e. (pred1^2 + pred2^2)\n", + "# cost0 = tf.reduce_sum(tf.square(y_pred), axis=[1, 2]) # (batch_size,)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 2 HITS: Permutation-invariant cost.\n", + "# # -------------------------------------------------------------------------\n", + "# # cost_1 corresponds to (hit1 → pred1, hit2 → pred2)\n", + "# dist_1_1 = tf.reduce_sum(tf.pow(tf.abs(y_true[:, 0, :] - y_pred[:, 0, :]), 3), axis=-1)\n", + "# dist_1_2 = tf.reduce_sum(tf.pow(tf.abs(y_true[:, 1, :] - y_pred[:, 1, :]), 3), axis=-1)\n", + "# cost_1 = dist_1_1 + dist_1_2\n", + "\n", + "# # cost_2 corresponds to (hit1 → pred2, hit2 → pred1)\n", + "# dist_2_1 = tf.reduce_sum(tf.pow(tf.abs(y_true[:, 0, :] - y_pred[:, 1, :]), 3), axis=-1)\n", + "# dist_2_2 = tf.reduce_sum(tf.pow(tf.abs(y_true[:, 1, :] - y_pred[:, 0, :]), 3), axis=-1)\n", + "# cost_2 = dist_2_1 + dist_2_2\n", + "\n", + "# cost2 = tf.minimum(cost_1, cost_2) # (batch_size,)\n", + "\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 1 HIT:\n", + "# # - Identify which row is the real hit (row0 or row1).\n", + "# # - Compute MSE for matching that hit to whichever predicted row is closer.\n", + "# # - Penalize the other predicted row for not being (0,0).\n", + "# # -------------------------------------------------------------------------\n", + "# row0_is_hit = row_nonzero[:, 0] # (batch_size,)\n", + "# # ground-truth single hit => either tile_true[:,0,:] or tile_true[:,1,:]\n", + "# gt_hit = tf.where(\n", + "# tf.expand_dims(row0_is_hit, axis=-1),\n", + "# y_true[:, 0, :],\n", + "# y_true[:, 1, :]\n", + "# ) # (batch_size, 2)\n", + "\n", + "# # Distances to each predicted point\n", + "# dist_pred_0 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 0, :]), axis=-1)\n", + "# dist_pred_1 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 1, :]), axis=-1)\n", + "\n", + "# # Also penalize the other row for not being near (0,0).\n", + "# zero_cost_0 = tf.reduce_sum(tf.square(y_pred[:, 0, :]), axis=-1)\n", + "# zero_cost_1 = tf.reduce_sum(tf.square(y_pred[:, 1, :]), axis=-1)\n", + "\n", + "# # Two ways to match:\n", + "# # -- pred_0 is the real hit => dist_pred_0 + zero_cost_1\n", + "# # -- pred_1 is the real hit => dist_pred_1 + zero_cost_0\n", + "# cost_if_0_matched = dist_pred_0 + zero_cost_1\n", + "# cost_if_1_matched = dist_pred_1 + zero_cost_0\n", + "# cost1 = tf.minimum(cost_if_0_matched, cost_if_1_matched) # (batch_size,)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # Combine costs across all tiles\n", + "# # For each tile i, only one of mask_0, mask_1, mask_2 is True.\n", + "# # -------------------------------------------------------------------------\n", + "# total_cost = (mask_1_f * cost1) + (mask_2_f * cost2)\n", + "\n", + "# # Average over the batch\n", + "# loss = (tf.reduce_mean(total_cost))+ (mask_0_f * cost0 )\n", + "# return loss\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "with 3 hits max" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def hungarian_loss_for_three_hits(y_true, y_pred,\n", + "# w_0=1.0,\n", + "# w_1=1.0,\n", + "# w_2=1.0,\n", + "# w_3=1.0):\n", + "# \"\"\"\n", + "# Hungarian-style loss for up to 3 hits per tile.\n", + "\n", + "# y_true, y_pred: shape (batch, 3, 2)\n", + "# - For each tile in the batch, we have up to 3 ground-truth hits (x,y),\n", + "# with zero-padding for unused hits: (0,0).\n", + "# - Similarly, model outputs 3 predicted hits, each is (x,y).\n", + "\n", + "# We find how many actual hits (0..3) each tile has, then:\n", + "# - 0 hits => cost0\n", + "# - 1 hit => cost1\n", + "# - 2 hits => cost2\n", + "# - 3 hits => cost3\n", + "# Then combine them with optional weighting w_0..w_3.\n", + "\n", + "# Returns:\n", + "# loss: scalar\n", + "# debug_info: dictionary with partial losses and counts\n", + "# \"\"\"\n", + "# # Cast to float32\n", + "# y_true = tf.cast(y_true, tf.float32)\n", + "# y_pred = tf.cast(y_pred, tf.float32)\n", + "\n", + "# # row_nonzero[i] => bool: True if y_true[i]!= (0,0)\n", + "# # shape: (batch, 3)\n", + "# row_nonzero = tf.reduce_any(tf.not_equal(y_true, 0.0), axis=-1)\n", + "\n", + "# # num_hits in {0,1,2,3} per tile\n", + "# num_hits = tf.reduce_sum(tf.cast(row_nonzero, tf.float32), axis=-1) # shape: (batch,)\n", + "\n", + "# # Create masks\n", + "# mask_0 = tf.equal(num_hits, 0.0)\n", + "# mask_1 = tf.equal(num_hits, 1.0)\n", + "# mask_2 = tf.equal(num_hits, 2.0)\n", + "# mask_3 = tf.equal(num_hits, 3.0)\n", + "\n", + "# mask_0_f = tf.cast(mask_0, tf.float32)\n", + "# mask_1_f = tf.cast(mask_1, tf.float32)\n", + "# mask_2_f = tf.cast(mask_2, tf.float32)\n", + "# mask_3_f = tf.cast(mask_3, tf.float32)\n", + "\n", + "# # ----------------------------\n", + "# # cost0 => tile has 0 hits\n", + "# # All predicted => (0,0), so MSE across all 3 predicted hits\n", + "# # shape of y_pred[:, k, :] = (batch, 2)\n", + "# # We'll sum squares for each slot\n", + "# # Then sum across 3 slots\n", + "# # ----------------------------\n", + "# cost0 = tf.reduce_sum(tf.square(y_pred), axis=[1,2]) # shape (batch,)\n", + "\n", + "# # ----------------------------\n", + "# # cost3 => tile has 3 hits\n", + "# # We'll do the 3! = 6 permutations, pick min\n", + "# # For each permutation p of (0,1,2):\n", + "# # cost_p = sum( squaredError( y_true[i], y_pred[ p(i) ] ) ) for i in {0,1,2}\n", + "# # We'll define a small helper\n", + "# # ----------------------------\n", + "# def cost_for_perm(perm, y_t, y_p):\n", + "# \"\"\"\n", + "# perm: e.g. [0,1,2]\n", + "# y_t, y_p: shape (batch, 3, 2)\n", + "# returns: shape (batch,)\n", + "# \"\"\"\n", + "# # y_true[i], y_pred[perm[i]]\n", + "# c0 = tf.reduce_sum(tf.square(y_t[:,0,:] - y_p[:,perm[0],:]), axis=-1)\n", + "# c1 = tf.reduce_sum(tf.square(y_t[:,1,:] - y_p[:,perm[1],:]), axis=-1)\n", + "# c2 = tf.reduce_sum(tf.square(y_t[:,2,:] - y_p[:,perm[2],:]), axis=-1)\n", + "# return c0 + c1 + c2\n", + "\n", + "# perm0 = cost_for_perm([0,1,2], y_true, y_pred)\n", + "# perm1 = cost_for_perm([0,2,1], y_true, y_pred)\n", + "# perm2 = cost_for_perm([1,0,2], y_true, y_pred)\n", + "# perm3 = cost_for_perm([1,2,0], y_true, y_pred)\n", + "# perm4 = cost_for_perm([2,0,1], y_true, y_pred)\n", + "# perm5 = cost_for_perm([2,1,0], y_true, y_pred)\n", + "\n", + "# # cost3 => min of all 6 permutations\n", + "# cost3 = tf.minimum(\n", + "# tf.minimum(tf.minimum(perm0, perm1), tf.minimum(perm2, perm3)),\n", + "# tf.minimum(perm4, perm5)\n", + "# )\n", + "\n", + "# # ----------------------------\n", + "# # cost2 => tile has 2 hits\n", + "# # We'll do all permutations of 2 hits in 3 predicted slots:\n", + "# # \"Which predicted slots do we pair, and which slot is leftover?\"\n", + "# #\n", + "# # or simpler approach:\n", + "# # - we can do permutations [0,1], [0,2], [1,0], [1,2], ...\n", + "# # - but let's do a direct 2! approach for the 2 used hits\n", + "# # - We also need to handle which predicted slot remains \"0\" => we add cost for that slot => (0,0).\n", + "# #\n", + "# # For clarity, let's define a small enumerations approach.\n", + "# # ----------------------------\n", + "# def cost2_fn(y_t, y_p):\n", + "# \"\"\"\n", + "# y_t, y_p => shape (batch, 3, 2), but we only use the first 2 rows of y_t as real hits\n", + "# We'll consider how to match them to any 2 of the 3 predicted slots, plus the leftover slot => (0,0).\n", + "# \"\"\"\n", + "# # We'll define all combos of 2 predicted slots out of 3 => (3 choose 2 = 3 combos)\n", + "# # For each combo, do a 2! = 2 permutations check. Then add the cost for the leftover slot => (0,0).\n", + "# # leftover slot => sum of squares of that predicted => cost of \"should be zero\"\n", + "# # We'll define a small helper to handle a single combination\n", + "# def c2_helper(gt0, gt1, p0, p1, p_left):\n", + "# # cost of matching gt0->p0, gt1->p1\n", + "# c0 = tf.reduce_sum(tf.square(gt0 - p0), axis=-1)\n", + "# c1 = tf.reduce_sum(tf.square(gt1 - p1), axis=-1)\n", + "# # leftover => must be zero => cost of p_left\n", + "# cz = tf.reduce_sum(tf.square(p_left), axis=-1)\n", + "# return c0 + c1 + cz\n", + "\n", + "# # ground-truth hits for row 0,1 => shape (batch,2)\n", + "# gt0 = y_t[:,0,:]\n", + "# gt1 = y_t[:,1,:]\n", + "\n", + "# # predicted slot 0 => y_p[:,0,:]\n", + "# # predicted slot 1 => y_p[:,1,:]\n", + "# # predicted slot 2 => y_p[:,2,:]\n", + "\n", + "# # combo #1: use pred0, pred1 => leftover pred2\n", + "# # two permutations => (gt0->pred0, gt1->pred1) or (gt0->pred1, gt1->pred0)\n", + "# c0_1 = c2_helper(gt0, gt1, y_p[:,0,:], y_p[:,1,:], y_p[:,2,:])\n", + "# c0_2 = c2_helper(gt0, gt1, y_p[:,1,:], y_p[:,0,:], y_p[:,2,:])\n", + "# combo1 = tf.minimum(c0_1, c0_2)\n", + "\n", + "# # combo #2: use pred0, pred2 => leftover pred1\n", + "# c1_1 = c2_helper(gt0, gt1, y_p[:,0,:], y_p[:,2,:], y_p[:,1,:])\n", + "# c1_2 = c2_helper(gt0, gt1, y_p[:,2,:], y_p[:,0,:], y_p[:,1,:])\n", + "# combo2 = tf.minimum(c1_1, c1_2)\n", + "\n", + "# # combo #3: use pred1, pred2 => leftover pred0\n", + "# c2_1 = c2_helper(gt0, gt1, y_p[:,1,:], y_p[:,2,:], y_p[:,0,:])\n", + "# c2_2 = c2_helper(gt0, gt1, y_p[:,2,:], y_p[:,1,:], y_p[:,0,:])\n", + "# combo3 = tf.minimum(c2_1, c2_2)\n", + "\n", + "# # cost2 => min of the 3 combos\n", + "# return tf.minimum(combo1, tf.minimum(combo2, combo3))\n", + "\n", + "# cost2 = cost2_fn(y_true, y_pred)\n", + "\n", + "# # ----------------------------\n", + "# # cost1 => tile has 1 hit\n", + "# # We'll do all 3 possible predicted slots, pick whichever is best => leftover => (0,0).\n", + "# # So we do:\n", + "# # cost if we match gt0->pred0, leftover => pred1,pred2 => cost( (0,0), pred1 ) + cost( (0,0), pred2 )\n", + "# # cost if we match gt0->pred1, leftover => pred0,pred2\n", + "# # cost if we match gt0->pred2, leftover => pred0,pred1\n", + "# #\n", + "# # ground-truth single => y_true[:,0,:], ignoring the other rows\n", + "# # or we can see which row is nonzero, but let's assume row0 is the real one for simplicity\n", + "# # If you want to handle \"maybe row1 is the real one,\" do a small logic as well\n", + "# # but let's do the simpler approach: we always assume row0 is the real single hit,\n", + "# # or you can do a mini-loop if you want the best among the 3 GT rows that is nonzero.\n", + "# # For demonstration, let's do the best among the 3 GT rows. We'll keep it short though.\n", + "# # ----------------------------\n", + "# def cost1_fn(y_t, y_p):\n", + "# # find which row of y_t is nonzero => we can do a max to find the actual row index\n", + "# # or simpler: consider each row i in [0..2], check if it's nonzero, compute cost matching it to pred slot\n", + "# # Then pick the minimal among them. We'll do a direct approach:\n", + "# # We'll do a small function that matches \"gt\" => \"pX\" leftover => the others => zero\n", + "# def c1_helper(gt, p_used, p_lft1, p_lft2):\n", + "# cost_hit = tf.reduce_sum(tf.square(gt - p_used), axis=-1)\n", + "# cost_z1 = tf.reduce_sum(tf.square(p_lft1), axis=-1)\n", + "# cost_z2 = tf.reduce_sum(tf.square(p_lft2), axis=-1)\n", + "# return cost_hit + cost_z1 + cost_z2\n", + "\n", + "# # row0 => y_t[:,0,:]\n", + "# # row1 => y_t[:,1,:]\n", + "# # row2 => y_t[:,2,:]\n", + "# # We'll compute cost if row0 is the real hit, row1 is real, row2 is real\n", + "# # whichever row is actually nonzero, that cost is valid. We'll keep them all and take min for each tile\n", + "# # because the tile might have exactly 1 nonzero row in practice\n", + "\n", + "# c_r0p0 = c1_helper(y_t[:,0,:], y_p[:,0,:], y_p[:,1,:], y_p[:,2,:])\n", + "# c_r0p1 = c1_helper(y_t[:,0,:], y_p[:,1,:], y_p[:,0,:], y_p[:,2,:])\n", + "# c_r0p2 = c1_helper(y_t[:,0,:], y_p[:,2,:], y_p[:,0,:], y_p[:,1,:])\n", + "\n", + "# c_r1p0 = c1_helper(y_t[:,1,:], y_p[:,0,:], y_p[:,1,:], y_p[:,2,:])\n", + "# c_r1p1 = c1_helper(y_t[:,1,:], y_p[:,1,:], y_p[:,0,:], y_p[:,2,:])\n", + "# c_r1p2 = c1_helper(y_t[:,1,:], y_p[:,2,:], y_p[:,0,:], y_p[:,1,:])\n", + "\n", + "# c_r2p0 = c1_helper(y_t[:,2,:], y_p[:,0,:], y_p[:,1,:], y_p[:,2,:])\n", + "# c_r2p1 = c1_helper(y_t[:,2,:], y_p[:,1,:], y_p[:,0,:], y_p[:,2,:])\n", + "# c_r2p2 = c1_helper(y_t[:,2,:], y_p[:,2,:], y_p[:,0,:], y_p[:,1,:])\n", + "\n", + "# # We'll gather them in a big stack => shape (batch,9). Then pick the min across axis=1\n", + "# big_cost = tf.stack([c_r0p0, c_r0p1, c_r0p2,\n", + "# c_r1p0, c_r1p1, c_r1p2,\n", + "# c_r2p0, c_r2p1, c_r2p2],\n", + "# axis=1)\n", + "# # pick min for each tile\n", + "# return tf.reduce_min(big_cost, axis=1)\n", + "\n", + "# cost1 = cost1_fn(y_true, y_pred)\n", + "\n", + "# # ----------------------------\n", + "# # Weighted combination\n", + "# # We'll define mask_3_f and w_3 for 3 hits\n", + "# # then total_cost => sum( mask_0_f* w_0* cost0, etc.)\n", + "# # ----------------------------\n", + "# weighted_cost_0 = w_0 * cost0\n", + "# weighted_cost_1 = w_1 * cost1\n", + "# weighted_cost_2 = w_2 * cost2\n", + "# weighted_cost_3 = w_3 * cost3\n", + "\n", + "# total_cost = (\n", + "# mask_0_f * weighted_cost_0 +\n", + "# mask_1_f * weighted_cost_1 +\n", + "# mask_2_f * weighted_cost_2 +\n", + "# mask_3_f * weighted_cost_3\n", + "# )\n", + "# loss = tf.reduce_mean(total_cost)\n", + "\n", + "# # For partial debugging\n", + "# eps = 0\n", + "# num0 = tf.reduce_sum(mask_0_f)\n", + "# num1 = tf.reduce_sum(mask_1_f)\n", + "# num2 = tf.reduce_sum(mask_2_f)\n", + "# num3 = tf.reduce_sum(mask_3_f)\n", + "\n", + "# avg_cost0 = tf.reduce_sum(mask_0_f * cost0) / (num0 + eps)\n", + "# avg_cost1 = tf.reduce_sum(mask_1_f * cost1) / (num1 + eps)\n", + "# avg_cost2 = tf.reduce_sum(mask_2_f * cost2) / (num2 + eps)\n", + "# avg_cost3 = tf.reduce_sum(mask_3_f * cost3) / (num3 + eps)\n", + "\n", + "# debug_info = {\n", + "# \"avg_cost0\": avg_cost0,\n", + "# \"avg_cost1\": avg_cost1,\n", + "# \"avg_cost2\": avg_cost2,\n", + "# \"avg_cost3\": avg_cost3,\n", + "# \"num0\": num0,\n", + "# \"num1\": num1,\n", + "# \"num2\": num2,\n", + "# \"num3\": num3,\n", + "# }\n", + "\n", + "# return loss, debug_info\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def make_hungarian_loss_and_metrics(w_0=1.0, w_1=1.0, w_2=1.0):\n", + "# \"\"\"\n", + "# Returns:\n", + "# hungarian_loss_fn (callable): main loss for model.compile(loss=...)\n", + "# metric_0_hit (callable): returns avg_cost0\n", + "# metric_1_hit (callable): returns avg_cost1\n", + "# metric_2_hit (callable): returns avg_cost2\n", + "# \"\"\"\n", + "\n", + "# def hungarian_loss_fn(y_true, y_pred):\n", + "# loss, _ = hungarian_loss_for_two_hits_vectorized(\n", + "# y_true, y_pred, w_0=w_0, w_1=w_1, w_2=w_2\n", + "# )\n", + "# return loss\n", + "\n", + "# def metric_0_hit(y_true, y_pred):\n", + "# _, debug_info = hungarian_loss_for_two_hits_vectorized(\n", + "# y_true, y_pred, w_0=w_0, w_1=w_1, w_2=w_2\n", + "# )\n", + "# return debug_info[\"avg_cost0\"]\n", + "\n", + "# def metric_1_hit(y_true, y_pred):\n", + "# _, debug_info = hungarian_loss_for_two_hits_vectorized(\n", + "# y_true, y_pred, w_0=w_0, w_1=w_1, w_2=w_2\n", + "# )\n", + "# return debug_info[\"avg_cost1\"]\n", + "\n", + "# def metric_2_hit(y_true, y_pred):\n", + "# _, debug_info = hungarian_loss_for_two_hits_vectorized(\n", + "# y_true, y_pred, w_0=w_0, w_1=w_1, w_2=w_2\n", + "# )\n", + "# return debug_info[\"avg_cost2\"]\n", + "\n", + "# return hungarian_loss_fn, metric_0_hit, metric_1_hit, metric_2_hit\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def make_hungarian_loss_3_and_metrics(w_0=1.0, w_1=1.0, w_2=1.0, w_3=1.0):\n", + "# \"\"\"\n", + "# Returns a Keras-compatible loss + metrics for up to 3 hits.\n", + "# \"\"\"\n", + "\n", + "# def hungarian_loss_fn(y_true, y_pred):\n", + "# loss, _ = hungarian_loss_for_three_hits(\n", + "# y_true, y_pred,\n", + "# w_0=w_0, w_1=w_1, w_2=w_2, w_3=w_3\n", + "# )\n", + "# return loss\n", + "\n", + "# def metric_0_hit(y_true, y_pred):\n", + "# _, dbg = hungarian_loss_for_three_hits(\n", + "# y_true, y_pred,\n", + "# w_0=w_0, w_1=w_1, w_2=w_2, w_3=w_3\n", + "# )\n", + "# return dbg[\"avg_cost0\"]\n", + "\n", + "# def metric_1_hit(y_true, y_pred):\n", + "# _, dbg = hungarian_loss_for_three_hits(\n", + "# y_true, y_pred,\n", + "# w_0=w_0, w_1=w_1, w_2=w_2, w_3=w_3\n", + "# )\n", + "# return dbg[\"avg_cost1\"]\n", + "\n", + "# def metric_2_hit(y_true, y_pred):\n", + "# _, dbg = hungarian_loss_for_three_hits(\n", + "# y_true, y_pred,\n", + "# w_0=w_0, w_1=w_1, w_2=w_2, w_3=w_3\n", + "# )\n", + "# return dbg[\"avg_cost2\"]\n", + "\n", + "# def metric_3_hit(y_true, y_pred):\n", + "# _, dbg = hungarian_loss_for_three_hits(\n", + "# y_true, y_pred,\n", + "# w_0=w_0, w_1=w_1, w_2=w_2, w_3=w_3\n", + "# )\n", + "# return dbg[\"avg_cost3\"]\n", + "\n", + "# return hungarian_loss_fn, metric_0_hit, metric_1_hit, metric_2_hit, metric_3_hit\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### no object loss" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def hungarian_bce_mse_loss(y_true, y_pred,\n", + " w_bce=1.0,\n", + " w_coord=1.0,\n", + " leftover_coord_penalty=0.1):\n", + " \"\"\"\n", + " Custom loss function handling cases based on tile hits.\n", + " y_true, y_pred: shape (batch, 2, 3).\n", + " For each tile:\n", + " slot j => [presence_j, x_j, y_j].\n", + " presence_j in y_true is 0 or 1, in y_pred is a logit.\n", + "\n", + " Returns: scalar loss.\n", + " \"\"\"\n", + "\n", + " # Separate presence and coordinates\n", + " gt_pres = y_true[:, :, 0] # Ground truth presence\n", + " pred_pres_logit = y_pred[:, :, 0] # Predicted presence logits\n", + " gt_xy = y_true[:, :, 1:3] # Ground truth coordinates\n", + " pred_xy = y_pred[:, :, 1:3] # Predicted coordinates\n", + "\n", + " # Binary cross-entropy for presence\n", + " bce_per_slot = tf.nn.sigmoid_cross_entropy_with_logits(\n", + " labels=gt_pres, \n", + " logits=pred_pres_logit\n", + " ) # shape (batch, 2)\n", + "\n", + " # MSE for coordinates\n", + " coord_diff = tf.pow(gt_xy - pred_xy, 2) # Squared difference (batch, 2, 2)\n", + " mse_per_slot = tf.reduce_sum(coord_diff, axis=-1) # Sum over x, y => shape (batch, 2)\n", + "\n", + " # Permutation handling for coordinates\n", + " perm_idx = tf.constant([1, 0], dtype=tf.int32)\n", + " pred_xy_swap = tf.gather(pred_xy, perm_idx, axis=1) # Swap prediction slots\n", + " coord_diff_swap = tf.pow(gt_xy - pred_xy_swap, 2) # Swapped squared difference\n", + " mse_per_slot_swap = tf.reduce_sum(coord_diff_swap, axis=-1) # shape (batch, 2)\n", + "\n", + " # Total BCE for each tile\n", + " bce_loss_per_tile = tf.reduce_sum(bce_per_slot, axis=-1) # Sum across slots (batch,)\n", + "\n", + " # Compute total costs for each case\n", + " hits_count = tf.reduce_sum(gt_pres, axis=-1) # Total hits per tile (batch,)\n", + "\n", + " # Case 1: Two hits (both slots occupied)\n", + " two_hits_mask = tf.equal(hits_count, 2.0)\n", + " two_hits_mask_f = tf.cast(two_hits_mask, tf.float32)\n", + " coord_loss_2_hits = tf.reduce_sum(mse_per_slot, axis=-1)\n", + " coord_loss_2_hits_swap = tf.reduce_sum(mse_per_slot_swap, axis=-1)\n", + " coord_loss_2_hits_final = tf.minimum(coord_loss_2_hits, coord_loss_2_hits_swap)\n", + "\n", + " # Case 2: One hit (one slot occupied)\n", + " one_hit_mask = tf.equal(hits_count, 1.0)\n", + " one_hit_mask_f = tf.cast(one_hit_mask, tf.float32)\n", + " bce_loss_one_hit = tf.reduce_sum((1.0 - gt_pres) * bce_per_slot, axis=-1)\n", + " coord_loss_one_hit = tf.reduce_sum(gt_pres * mse_per_slot, axis=-1)\n", + " total_loss_one_hit_direct = bce_loss_one_hit + coord_loss_one_hit\n", + "\n", + " # Handle permutation for one hit\n", + " bce_loss_one_hit_swap = tf.reduce_sum((1.0 - gt_pres) * bce_per_slot, axis=-1)\n", + " coord_loss_one_hit_swap = tf.reduce_sum(gt_pres * mse_per_slot_swap, axis=-1)\n", + " total_loss_one_hit_swap = bce_loss_one_hit_swap + coord_loss_one_hit_swap\n", + " coord_loss_1_hit_final = tf.minimum(total_loss_one_hit_direct, total_loss_one_hit_swap)\n", + "\n", + " # Case 3: Zero hits (no slots occupied)\n", + " zero_hits_mask = tf.equal(hits_count, 0.0)\n", + " zero_hits_mask_f = tf.cast(zero_hits_mask, tf.float32)\n", + " coord_loss_0_hits_final = tf.reduce_sum(bce_per_slot, axis=-1)\n", + "\n", + " # Combine losses for all cases\n", + " total_loss = (\n", + " two_hits_mask_f * coord_loss_2_hits_final +\n", + " one_hit_mask_f * coord_loss_1_hit_final +\n", + " zero_hits_mask_f * coord_loss_0_hits_final\n", + " )\n", + "\n", + " # Average loss over all tiles\n", + " loss = tf.reduce_mean(total_loss)\n", + "\n", + " return loss\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 6)              │           774 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape (Reshape)               │ (None, 2, 3)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m) │ \u001b[38;5;34m774\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 84,166 (328.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m84,166\u001b[0m (328.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 84,166 (328.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m84,166\u001b[0m (328.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# loss_fn, m0, m1, m2, m3 = make_hungarian_loss_3_and_metrics(\n", + "# w_0=1.0, w_1=5.0, w_2=5.0, w_3=5.0\n", + "# )\n", + "\n", + "# Get the 4 callables\n", + "# loss_fn, metric0, metric1, metric2 = make_hungarian_loss_and_metrics(w_0=1, w_1=1, w_2=3)\n", + "\n", + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(\n", + " optimizer='adam',\n", + " loss=hungarian_bce_mse_loss\n", + ")\n", + "\n", + "\n", + "\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<_BatchDataset element_spec=(TensorSpec(shape=(None, 8, 8, 1), dtype=tf.float64, name=None), TensorSpec(shape=(None, 2, 2), dtype=tf.float64, name=None))>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 18:26:07.259061: W tensorflow/core/kernels/gpu_utils.cc:68] Failed to allocate memory for convolution redzone checking; skipping this check. This is benign and only means that we won't check cudnn for out-of-bounds reads and writes. This message will only be printed once.\n", + "2025-01-18 18:26:07.268593: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1737242767.326738 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.368225 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.374988 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.379430 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.424995 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.479954 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.480098 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.540505 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.558259 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.576524 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.601506 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.625979 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.656435 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.685156 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.702720 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.750085 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.810122 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.865611 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.989243 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.994270 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242767.998944 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.056356 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.061172 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.270806 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.278560 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.283100 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.287733 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.292395 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.297022 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.301601 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.308323 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.313498 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.318768 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.323970 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.329733 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242768.335535 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242769.175718 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242769.181151 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242769.186532 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242769.195197 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242769.202142 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242769.211213 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242769.220142 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.576900 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.586416 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.595640 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.606146 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.621476 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.632704 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.642250 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.653185 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.665058 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.674354 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.686430 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.698568 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.711472 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.720736 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.733145 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.748355 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.763407 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.776279 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.797045 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.814468 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242770.842659 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.064275 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.094374 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.515642 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.524285 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.531354 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.538029 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.545166 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.551261 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.557478 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.564372 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.571730 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.580304 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.589682 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.596993 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.607562 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.625689 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.787020 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.810168 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.843728 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.875533 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.907297 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.938848 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.975289 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.991595 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242771.991663 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242772.163929 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/72\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m8:01\u001b[0m 7s/step - loss: 1.2732" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737242772.220747 2834845 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m71/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 619ms/step - loss: 0.7512" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 18:26:55.674988: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2025-01-18 18:26:55.675132: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1737242815.692429 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.694706 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.696633 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.710996 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.711145 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.713776 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.727606 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.727648 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.735763 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.748764 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.753446 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.758233 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.764679 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.770889 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.778641 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.785938 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.790476 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.802423 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.817588 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.830969 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.841548 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.856420 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.872457 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.874045 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.875389 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.890020 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.891400 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.944604 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.946761 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.948080 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.949397 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.950741 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.952071 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.953399 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.955234 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.971038 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.972494 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.973979 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.975503 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.977090 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.978683 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.980743 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.982238 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.983755 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.986133 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.988088 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.990705 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242815.993285 2834850 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.015116 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.017803 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.020348 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.023245 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.027282 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.030275 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.032862 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.035814 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.038955 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.041204 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.044318 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.047484 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.050785 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.053214 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.056447 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.060371 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.064286 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.067640 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.072952 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.077452 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.084682 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.140323 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.148092 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.251460 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.253269 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.255208 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.257047 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.258998 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.260707 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.262478 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.264362 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.266371 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.268680 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.271174 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.273445 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.276258 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.280949 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.290768 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.326879 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.335531 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 621ms/step - loss: 0.7455" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1737242816.343692 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.351839 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.359934 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.369285 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.373681 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.373733 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.417490 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242816.430648 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.524215 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.532810 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.541247 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.550510 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.558317 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.568383 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.576913 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.585894 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.598426 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.612278 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.623826 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.634551 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.649847 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.663982 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.679362 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.693511 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.708933 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.722621 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.739328 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.751091 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.763739 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.806547 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.880281 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.889912 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.898866 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.962564 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.980880 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242817.995731 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242818.014432 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242818.041611 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242818.106619 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242818.126979 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242818.143228 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242818.185542 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242818.254516 2834849 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "2025-01-18 18:26:59.083976: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1737242819.100437 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.106939 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.113320 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.120354 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.127929 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.134212 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.140137 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.146807 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.156061 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.166439 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.175158 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.183324 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.194879 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.205548 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.217261 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.227917 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.238066 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.248336 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.256659 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.268542 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.296486 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.306114 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.361420 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.365604 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.372367 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.420141 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.447158 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.460944 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.472140 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.486230 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.506312 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.544781 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.560071 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.572286 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.604372 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1737242819.656658 2834844 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m54s\u001b[0m 667ms/step - loss: 0.7399 - val_loss: 0.0033 - learning_rate: 0.0010\n", + "Epoch 2/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 305ms/step - loss: 0.0031 - val_loss: 0.0027 - learning_rate: 0.0010\n", + "Epoch 3/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 18:27:27.879459: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 0.0023 - val_loss: 0.0012 - learning_rate: 0.0010\n", + "Epoch 4/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 314ms/step - loss: 0.0011 - val_loss: 9.9098e-04 - learning_rate: 0.0010\n", + "Epoch 5/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 18:28:12.600398: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 231ms/step - loss: 9.4668e-04 - val_loss: 8.7767e-04 - learning_rate: 0.0010\n", + "Epoch 6/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m26s\u001b[0m 302ms/step - loss: 8.1890e-04 - val_loss: 7.3138e-04 - learning_rate: 0.0010\n", + "Epoch 7/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 237ms/step - loss: 6.7274e-04 - val_loss: 6.1991e-04 - learning_rate: 0.0010\n", + "Epoch 8/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 5.8230e-04 - val_loss: 5.8067e-04 - learning_rate: 0.0010\n", + "Epoch 9/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 18:29:35.457505: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 5.4919e-04 - val_loss: 5.6348e-04 - learning_rate: 0.0010\n", + "Epoch 10/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 231ms/step - loss: 5.3146e-04 - val_loss: 5.5309e-04 - learning_rate: 0.0010\n", + "Epoch 11/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 5.2080e-04 - val_loss: 5.4590e-04 - learning_rate: 0.0010\n", + "Epoch 12/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 5.1313e-04 - val_loss: 5.4059e-04 - learning_rate: 0.0010\n", + "Epoch 13/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 5.0734e-04 - val_loss: 5.3591e-04 - learning_rate: 0.0010\n", + "Epoch 14/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 5.0281e-04 - val_loss: 5.3210e-04 - learning_rate: 0.0010\n", + "Epoch 15/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 232ms/step - loss: 4.9916e-04 - val_loss: 5.2911e-04 - learning_rate: 0.0010\n", + "Epoch 16/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 294ms/step - loss: 4.9618e-04 - val_loss: 5.2650e-04 - learning_rate: 0.0010\n", + "Epoch 17/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 18:32:25.902263: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 238ms/step - loss: 4.9359e-04\n", + "Epoch 17: ReduceLROnPlateau reducing learning rate to 0.0009000000427477062.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 246ms/step - loss: 4.9358e-04 - val_loss: 5.2420e-04 - learning_rate: 0.0010\n", + "Epoch 18/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 252ms/step - loss: 4.9107e-04 - val_loss: 5.2253e-04 - learning_rate: 9.0000e-04\n", + "Epoch 19/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.8914e-04 - val_loss: 5.2064e-04 - learning_rate: 9.0000e-04\n", + "Epoch 20/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.8728e-04 - val_loss: 5.1893e-04 - learning_rate: 9.0000e-04\n", + "Epoch 21/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.8553e-04 - val_loss: 5.1722e-04 - learning_rate: 9.0000e-04\n", + "Epoch 22/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.8385e-04 - val_loss: 5.1555e-04 - learning_rate: 9.0000e-04\n", + "Epoch 23/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 232ms/step - loss: 4.8242e-04 - val_loss: 5.1427e-04 - learning_rate: 9.0000e-04\n", + "Epoch 24/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 303ms/step - loss: 4.8109e-04 - val_loss: 5.1280e-04 - learning_rate: 9.0000e-04\n", + "Epoch 25/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 246ms/step - loss: 4.7986e-04 - val_loss: 5.1174e-04 - learning_rate: 9.0000e-04\n", + "Epoch 26/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.7876e-04 - val_loss: 5.1086e-04 - learning_rate: 9.0000e-04\n", + "Epoch 27/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.7765e-04 - val_loss: 5.0991e-04 - learning_rate: 9.0000e-04\n", + "Epoch 28/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.7671e-04 - val_loss: 5.0906e-04 - learning_rate: 9.0000e-04\n", + "Epoch 29/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 302ms/step - loss: 4.7581e-04 - val_loss: 5.0850e-04 - learning_rate: 9.0000e-04\n", + "Epoch 30/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.7498e-04\n", + "Epoch 30: ReduceLROnPlateau reducing learning rate to 0.0008100000384729356.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 232ms/step - loss: 4.7497e-04 - val_loss: 5.0797e-04 - learning_rate: 9.0000e-04\n", + "Epoch 31/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.7390e-04 - val_loss: 5.0756e-04 - learning_rate: 8.1000e-04\n", + "Epoch 32/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.7324e-04 - val_loss: 5.0709e-04 - learning_rate: 8.1000e-04\n", + "Epoch 33/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 18:38:00.985474: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.7257e-04 - val_loss: 5.0656e-04 - learning_rate: 8.1000e-04\n", + "Epoch 34/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 303ms/step - loss: 4.7187e-04 - val_loss: 5.0606e-04 - learning_rate: 8.1000e-04\n", + "Epoch 35/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 232ms/step - loss: 4.7126e-04 - val_loss: 5.0582e-04 - learning_rate: 8.1000e-04\n", + "Epoch 36/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 234ms/step - loss: 4.7061e-04 - val_loss: 5.0560e-04 - learning_rate: 8.1000e-04\n", + "Epoch 37/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.7005e-04 - val_loss: 5.0527e-04 - learning_rate: 8.1000e-04\n", + "Epoch 38/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.6943e-04 - val_loss: 5.0463e-04 - learning_rate: 8.1000e-04\n", + "Epoch 39/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.6886e-04 - val_loss: 5.0416e-04 - learning_rate: 8.1000e-04\n", + "Epoch 40/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.6833e-04\n", + "Epoch 40: ReduceLROnPlateau reducing learning rate to 0.0007290000503417104.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.6832e-04 - val_loss: 5.0389e-04 - learning_rate: 8.1000e-04\n", + "Epoch 41/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.6750e-04 - val_loss: 5.0443e-04 - learning_rate: 7.2900e-04\n", + "Epoch 42/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.6722e-04 - val_loss: 5.0420e-04 - learning_rate: 7.2900e-04\n", + "Epoch 43/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 231ms/step - loss: 4.6672e-04 - val_loss: 5.0400e-04 - learning_rate: 7.2900e-04\n", + "Epoch 44/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 303ms/step - loss: 4.6627e-04 - val_loss: 5.0374e-04 - learning_rate: 7.2900e-04\n", + "Epoch 45/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 231ms/step - loss: 4.6577e-04 - val_loss: 5.0350e-04 - learning_rate: 7.2900e-04\n", + "Epoch 46/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 233ms/step - loss: 4.6532e-04 - val_loss: 5.0309e-04 - learning_rate: 7.2900e-04\n", + "Epoch 47/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.6494e-04 - val_loss: 5.0325e-04 - learning_rate: 7.2900e-04\n", + "Epoch 48/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.6450e-04 - val_loss: 5.0283e-04 - learning_rate: 7.2900e-04\n", + "Epoch 49/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.6410e-04 - val_loss: 5.0272e-04 - learning_rate: 7.2900e-04\n", + "Epoch 50/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.6364e-04\n", + "Epoch 50: ReduceLROnPlateau reducing learning rate to 0.0006561000715009868.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.6363e-04 - val_loss: 5.0254e-04 - learning_rate: 7.2900e-04\n", + "Epoch 51/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.6306e-04 - val_loss: 5.0245e-04 - learning_rate: 6.5610e-04\n", + "Epoch 52/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.6280e-04 - val_loss: 5.0204e-04 - learning_rate: 6.5610e-04\n", + "Epoch 53/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 232ms/step - loss: 4.6240e-04 - val_loss: 5.0199e-04 - learning_rate: 6.5610e-04\n", + "Epoch 54/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 302ms/step - loss: 4.6199e-04 - val_loss: 5.0173e-04 - learning_rate: 6.5610e-04\n", + "Epoch 55/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.6164e-04 - val_loss: 5.0155e-04 - learning_rate: 6.5610e-04\n", + "Epoch 56/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.6128e-04 - val_loss: 5.0142e-04 - learning_rate: 6.5610e-04\n", + "Epoch 57/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.6091e-04 - val_loss: 5.0130e-04 - learning_rate: 6.5610e-04\n", + "Epoch 58/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 231ms/step - loss: 4.6052e-04 - val_loss: 5.0120e-04 - learning_rate: 6.5610e-04\n", + "Epoch 59/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 303ms/step - loss: 4.6018e-04 - val_loss: 5.0119e-04 - learning_rate: 6.5610e-04\n", + "Epoch 60/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.5981e-04\n", + "Epoch 60: ReduceLROnPlateau reducing learning rate to 0.0005904900433961303.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.5980e-04 - val_loss: 5.0092e-04 - learning_rate: 6.5610e-04\n", + "Epoch 61/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.5923e-04 - val_loss: 5.0095e-04 - learning_rate: 5.9049e-04\n", + "Epoch 62/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.5901e-04 - val_loss: 5.0079e-04 - learning_rate: 5.9049e-04\n", + "Epoch 63/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 232ms/step - loss: 4.5863e-04 - val_loss: 5.0055e-04 - learning_rate: 5.9049e-04\n", + "Epoch 64/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 304ms/step - loss: 4.5837e-04 - val_loss: 5.0037e-04 - learning_rate: 5.9049e-04\n", + "Epoch 65/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 18:49:14.778011: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.5795e-04 - val_loss: 5.0023e-04 - learning_rate: 5.9049e-04\n", + "Epoch 66/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.5768e-04 - val_loss: 5.0013e-04 - learning_rate: 5.9049e-04\n", + "Epoch 67/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 305ms/step - loss: 4.5737e-04 - val_loss: 5.0022e-04 - learning_rate: 5.9049e-04\n", + "Epoch 68/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 231ms/step - loss: 4.5721e-04 - val_loss: 5.0042e-04 - learning_rate: 5.9049e-04\n", + "Epoch 69/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 304ms/step - loss: 4.5693e-04 - val_loss: 5.0052e-04 - learning_rate: 5.9049e-04\n", + "Epoch 70/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.5666e-04\n", + "Epoch 70: ReduceLROnPlateau reducing learning rate to 0.0005314410547725857.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 232ms/step - loss: 4.5665e-04 - val_loss: 5.0019e-04 - learning_rate: 5.9049e-04\n", + "Epoch 71/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.5610e-04 - val_loss: 5.0005e-04 - learning_rate: 5.3144e-04\n", + "Epoch 72/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 306ms/step - loss: 4.5598e-04 - val_loss: 5.0011e-04 - learning_rate: 5.3144e-04\n", + "Epoch 73/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.5572e-04 - val_loss: 5.0003e-04 - learning_rate: 5.3144e-04\n", + "Epoch 74/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.5542e-04 - val_loss: 5.0000e-04 - learning_rate: 5.3144e-04\n", + "Epoch 75/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 232ms/step - loss: 4.5520e-04 - val_loss: 4.9983e-04 - learning_rate: 5.3144e-04\n", + "Epoch 76/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m26s\u001b[0m 302ms/step - loss: 4.5497e-04 - val_loss: 4.9990e-04 - learning_rate: 5.3144e-04\n", + "Epoch 77/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 233ms/step - loss: 4.5465e-04 - val_loss: 4.9976e-04 - learning_rate: 5.3144e-04\n", + "Epoch 78/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.5442e-04 - val_loss: 5.0002e-04 - learning_rate: 5.3144e-04\n", + "Epoch 79/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.5423e-04 - val_loss: 4.9998e-04 - learning_rate: 5.3144e-04\n", + "Epoch 80/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 229ms/step - loss: 4.5404e-04\n", + "Epoch 80: ReduceLROnPlateau reducing learning rate to 0.00047829695977270604.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.5403e-04 - val_loss: 4.9976e-04 - learning_rate: 5.3144e-04\n", + "Epoch 81/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.5351e-04 - val_loss: 4.9965e-04 - learning_rate: 4.7830e-04\n", + "Epoch 82/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.5345e-04 - val_loss: 4.9942e-04 - learning_rate: 4.7830e-04\n", + "Epoch 83/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.5323e-04 - val_loss: 4.9953e-04 - learning_rate: 4.7830e-04\n", + "Epoch 84/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 303ms/step - loss: 4.5314e-04 - val_loss: 4.9932e-04 - learning_rate: 4.7830e-04\n", + "Epoch 85/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.5286e-04 - val_loss: 4.9938e-04 - learning_rate: 4.7830e-04\n", + "Epoch 86/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.5264e-04 - val_loss: 4.9952e-04 - learning_rate: 4.7830e-04\n", + "Epoch 87/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 302ms/step - loss: 4.5238e-04 - val_loss: 4.9951e-04 - learning_rate: 4.7830e-04\n", + "Epoch 88/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.5225e-04 - val_loss: 4.9943e-04 - learning_rate: 4.7830e-04\n", + "Epoch 89/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 298ms/step - loss: 4.5194e-04 - val_loss: 4.9955e-04 - learning_rate: 4.7830e-04\n", + "Epoch 90/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 227ms/step - loss: 4.5187e-04\n", + "Epoch 90: ReduceLROnPlateau reducing learning rate to 0.0004304672533180565.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 231ms/step - loss: 4.5186e-04 - val_loss: 4.9947e-04 - learning_rate: 4.7830e-04\n", + "Epoch 91/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.5144e-04 - val_loss: 4.9945e-04 - learning_rate: 4.3047e-04\n", + "Epoch 92/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.5132e-04 - val_loss: 4.9903e-04 - learning_rate: 4.3047e-04\n", + "Epoch 93/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 231ms/step - loss: 4.5107e-04 - val_loss: 4.9897e-04 - learning_rate: 4.3047e-04\n", + "Epoch 94/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 303ms/step - loss: 4.5090e-04 - val_loss: 4.9910e-04 - learning_rate: 4.3047e-04\n", + "Epoch 95/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.5072e-04 - val_loss: 4.9904e-04 - learning_rate: 4.3047e-04\n", + "Epoch 96/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.5057e-04 - val_loss: 4.9882e-04 - learning_rate: 4.3047e-04\n", + "Epoch 97/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.5043e-04 - val_loss: 4.9919e-04 - learning_rate: 4.3047e-04\n", + "Epoch 98/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.5023e-04 - val_loss: 4.9906e-04 - learning_rate: 4.3047e-04\n", + "Epoch 99/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 304ms/step - loss: 4.5013e-04 - val_loss: 4.9894e-04 - learning_rate: 4.3047e-04\n", + "Epoch 100/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.4995e-04\n", + "Epoch 100: ReduceLROnPlateau reducing learning rate to 0.00038742052274756136.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4994e-04 - val_loss: 4.9909e-04 - learning_rate: 4.3047e-04\n", + "Epoch 101/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4956e-04 - val_loss: 4.9903e-04 - learning_rate: 3.8742e-04\n", + "Epoch 102/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 305ms/step - loss: 4.4940e-04 - val_loss: 4.9887e-04 - learning_rate: 3.8742e-04\n", + "Epoch 103/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4921e-04 - val_loss: 4.9895e-04 - learning_rate: 3.8742e-04\n", + "Epoch 104/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 304ms/step - loss: 4.4904e-04 - val_loss: 4.9898e-04 - learning_rate: 3.8742e-04\n", + "Epoch 105/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4889e-04 - val_loss: 4.9887e-04 - learning_rate: 3.8742e-04\n", + "Epoch 106/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4871e-04 - val_loss: 4.9878e-04 - learning_rate: 3.8742e-04\n", + "Epoch 107/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.4853e-04 - val_loss: 4.9882e-04 - learning_rate: 3.8742e-04\n", + "Epoch 108/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.4836e-04 - val_loss: 4.9870e-04 - learning_rate: 3.8742e-04\n", + "Epoch 109/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 303ms/step - loss: 4.4824e-04 - val_loss: 4.9862e-04 - learning_rate: 3.8742e-04\n", + "Epoch 110/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.4815e-04\n", + "Epoch 110: ReduceLROnPlateau reducing learning rate to 0.0003486784757114947.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4814e-04 - val_loss: 4.9852e-04 - learning_rate: 3.8742e-04\n", + "Epoch 111/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4781e-04 - val_loss: 4.9881e-04 - learning_rate: 3.4868e-04\n", + "Epoch 112/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.4770e-04 - val_loss: 4.9876e-04 - learning_rate: 3.4868e-04\n", + "Epoch 113/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 232ms/step - loss: 4.4752e-04 - val_loss: 4.9854e-04 - learning_rate: 3.4868e-04\n", + "Epoch 114/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 302ms/step - loss: 4.4742e-04 - val_loss: 4.9872e-04 - learning_rate: 3.4868e-04\n", + "Epoch 115/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4728e-04 - val_loss: 4.9855e-04 - learning_rate: 3.4868e-04\n", + "Epoch 116/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.4717e-04 - val_loss: 4.9884e-04 - learning_rate: 3.4868e-04\n", + "Epoch 117/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.4704e-04 - val_loss: 4.9866e-04 - learning_rate: 3.4868e-04\n", + "Epoch 118/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 232ms/step - loss: 4.4694e-04 - val_loss: 4.9861e-04 - learning_rate: 3.4868e-04\n", + "Epoch 119/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 303ms/step - loss: 4.4679e-04 - val_loss: 4.9858e-04 - learning_rate: 3.4868e-04\n", + "Epoch 120/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.4663e-04\n", + "Epoch 120: ReduceLROnPlateau reducing learning rate to 0.00031381062290165574.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 244ms/step - loss: 4.4663e-04 - val_loss: 4.9867e-04 - learning_rate: 3.4868e-04\n", + "Epoch 121/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 234ms/step - loss: 4.4644e-04 - val_loss: 4.9879e-04 - learning_rate: 3.1381e-04\n", + "Epoch 122/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 302ms/step - loss: 4.4630e-04 - val_loss: 4.9904e-04 - learning_rate: 3.1381e-04\n", + "Epoch 123/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 231ms/step - loss: 4.4618e-04 - val_loss: 4.9880e-04 - learning_rate: 3.1381e-04\n", + "Epoch 124/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 301ms/step - loss: 4.4607e-04 - val_loss: 4.9896e-04 - learning_rate: 3.1381e-04\n", + "Epoch 125/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4592e-04 - val_loss: 4.9889e-04 - learning_rate: 3.1381e-04\n", + "Epoch 126/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4584e-04 - val_loss: 4.9888e-04 - learning_rate: 3.1381e-04\n", + "Epoch 127/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 305ms/step - loss: 4.4567e-04 - val_loss: 4.9895e-04 - learning_rate: 3.1381e-04\n", + "Epoch 128/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 232ms/step - loss: 4.4560e-04 - val_loss: 4.9880e-04 - learning_rate: 3.1381e-04\n", + "Epoch 129/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-18 19:11:36.374629: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m26s\u001b[0m 309ms/step - loss: 4.4544e-04 - val_loss: 4.9900e-04 - learning_rate: 3.1381e-04\n", + "Epoch 130/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 229ms/step - loss: 4.4534e-04\n", + "Epoch 130: ReduceLROnPlateau reducing learning rate to 0.0002824295632308349.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 233ms/step - loss: 4.4533e-04 - val_loss: 4.9883e-04 - learning_rate: 3.1381e-04\n", + "Epoch 131/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4507e-04 - val_loss: 4.9915e-04 - learning_rate: 2.8243e-04\n", + "Epoch 132/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 311ms/step - loss: 4.4497e-04 - val_loss: 4.9914e-04 - learning_rate: 2.8243e-04\n", + "Epoch 133/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 233ms/step - loss: 4.4482e-04 - val_loss: 4.9910e-04 - learning_rate: 2.8243e-04\n", + "Epoch 134/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m26s\u001b[0m 320ms/step - loss: 4.4472e-04 - val_loss: 4.9889e-04 - learning_rate: 2.8243e-04\n", + "Epoch 135/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4463e-04 - val_loss: 4.9920e-04 - learning_rate: 2.8243e-04\n", + "Epoch 136/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4448e-04 - val_loss: 4.9895e-04 - learning_rate: 2.8243e-04\n", + "Epoch 137/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 310ms/step - loss: 4.4437e-04 - val_loss: 4.9881e-04 - learning_rate: 2.8243e-04\n", + "Epoch 138/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4422e-04 - val_loss: 4.9898e-04 - learning_rate: 2.8243e-04\n", + "Epoch 139/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 317ms/step - loss: 4.4414e-04 - val_loss: 4.9921e-04 - learning_rate: 2.8243e-04\n", + "Epoch 140/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.4406e-04\n", + "Epoch 140: ReduceLROnPlateau reducing learning rate to 0.00025418660952709616.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 258ms/step - loss: 4.4405e-04 - val_loss: 4.9894e-04 - learning_rate: 2.8243e-04\n", + "Epoch 141/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 326ms/step - loss: 4.4383e-04 - val_loss: 4.9940e-04 - learning_rate: 2.5419e-04\n", + "Epoch 142/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 235ms/step - loss: 4.4374e-04 - val_loss: 4.9933e-04 - learning_rate: 2.5419e-04\n", + "Epoch 143/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4360e-04 - val_loss: 4.9940e-04 - learning_rate: 2.5419e-04\n", + "Epoch 144/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 313ms/step - loss: 4.4348e-04 - val_loss: 4.9944e-04 - learning_rate: 2.5419e-04\n", + "Epoch 145/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 231ms/step - loss: 4.4344e-04 - val_loss: 4.9926e-04 - learning_rate: 2.5419e-04\n", + "Epoch 146/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 308ms/step - loss: 4.4332e-04 - val_loss: 4.9909e-04 - learning_rate: 2.5419e-04\n", + "Epoch 147/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4321e-04 - val_loss: 4.9941e-04 - learning_rate: 2.5419e-04\n", + "Epoch 148/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.4314e-04 - val_loss: 4.9951e-04 - learning_rate: 2.5419e-04\n", + "Epoch 149/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.4303e-04 - val_loss: 4.9916e-04 - learning_rate: 2.5419e-04\n", + "Epoch 150/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 227ms/step - loss: 4.4292e-04\n", + "Epoch 150: ReduceLROnPlateau reducing learning rate to 0.00022876793809700757.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 231ms/step - loss: 4.4291e-04 - val_loss: 4.9934e-04 - learning_rate: 2.5419e-04\n", + "Epoch 151/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 303ms/step - loss: 4.4269e-04 - val_loss: 4.9981e-04 - learning_rate: 2.2877e-04\n", + "Epoch 152/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4261e-04 - val_loss: 4.9966e-04 - learning_rate: 2.2877e-04\n", + "Epoch 153/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.4249e-04 - val_loss: 4.9957e-04 - learning_rate: 2.2877e-04\n", + "Epoch 154/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 301ms/step - loss: 4.4236e-04 - val_loss: 4.9966e-04 - learning_rate: 2.2877e-04\n", + "Epoch 155/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 232ms/step - loss: 4.4226e-04 - val_loss: 4.9951e-04 - learning_rate: 2.2877e-04\n", + "Epoch 156/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m26s\u001b[0m 303ms/step - loss: 4.4217e-04 - val_loss: 4.9954e-04 - learning_rate: 2.2877e-04\n", + "Epoch 157/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 231ms/step - loss: 4.4209e-04 - val_loss: 4.9948e-04 - learning_rate: 2.2877e-04\n", + "Epoch 158/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.4200e-04 - val_loss: 4.9953e-04 - learning_rate: 2.2877e-04\n", + "Epoch 159/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 299ms/step - loss: 4.4186e-04 - val_loss: 4.9951e-04 - learning_rate: 2.2877e-04\n", + "Epoch 160/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 227ms/step - loss: 4.4180e-04\n", + "Epoch 160: ReduceLROnPlateau reducing learning rate to 0.00020589114428730683.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 240ms/step - loss: 4.4179e-04 - val_loss: 4.9951e-04 - learning_rate: 2.2877e-04\n", + "Epoch 161/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 300ms/step - loss: 4.4160e-04 - val_loss: 4.9973e-04 - learning_rate: 2.0589e-04\n", + "Epoch 162/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 234ms/step - loss: 4.4151e-04 - val_loss: 4.9986e-04 - learning_rate: 2.0589e-04\n", + "Epoch 163/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.4140e-04 - val_loss: 4.9985e-04 - learning_rate: 2.0589e-04\n", + "Epoch 164/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 300ms/step - loss: 4.4132e-04 - val_loss: 4.9971e-04 - learning_rate: 2.0589e-04\n", + "Epoch 165/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 240ms/step - loss: 4.4119e-04 - val_loss: 4.9963e-04 - learning_rate: 2.0589e-04\n", + "Epoch 166/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.4110e-04 - val_loss: 4.9959e-04 - learning_rate: 2.0589e-04\n", + "Epoch 167/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 299ms/step - loss: 4.4101e-04 - val_loss: 4.9953e-04 - learning_rate: 2.0589e-04\n", + "Epoch 168/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 231ms/step - loss: 4.4094e-04 - val_loss: 4.9952e-04 - learning_rate: 2.0589e-04\n", + "Epoch 169/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 303ms/step - loss: 4.4086e-04 - val_loss: 4.9947e-04 - learning_rate: 2.0589e-04\n", + "Epoch 170/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.4076e-04\n", + "Epoch 170: ReduceLROnPlateau reducing learning rate to 0.00018530203378759326.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4076e-04 - val_loss: 4.9953e-04 - learning_rate: 2.0589e-04\n", + "Epoch 171/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.4057e-04 - val_loss: 4.9992e-04 - learning_rate: 1.8530e-04\n", + "Epoch 172/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 300ms/step - loss: 4.4054e-04 - val_loss: 4.9981e-04 - learning_rate: 1.8530e-04\n", + "Epoch 173/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 231ms/step - loss: 4.4045e-04 - val_loss: 4.9991e-04 - learning_rate: 1.8530e-04\n", + "Epoch 174/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 300ms/step - loss: 4.4038e-04 - val_loss: 4.9975e-04 - learning_rate: 1.8530e-04\n", + "Epoch 175/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4029e-04 - val_loss: 4.9999e-04 - learning_rate: 1.8530e-04\n", + "Epoch 176/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.4022e-04 - val_loss: 4.9988e-04 - learning_rate: 1.8530e-04\n", + "Epoch 177/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 304ms/step - loss: 4.4015e-04 - val_loss: 4.9984e-04 - learning_rate: 1.8530e-04\n", + "Epoch 178/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.4003e-04 - val_loss: 4.9994e-04 - learning_rate: 1.8530e-04\n", + "Epoch 179/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 231ms/step - loss: 4.3997e-04 - val_loss: 4.9991e-04 - learning_rate: 1.8530e-04\n", + "Epoch 180/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 293ms/step - loss: 4.3988e-04\n", + "Epoch 180: ReduceLROnPlateau reducing learning rate to 0.00016677183302817866.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.3987e-04 - val_loss: 4.9972e-04 - learning_rate: 1.8530e-04\n", + "Epoch 181/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 232ms/step - loss: 4.3975e-04 - val_loss: 5.0024e-04 - learning_rate: 1.6677e-04\n", + "Epoch 182/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 264ms/step - loss: 4.3969e-04 - val_loss: 5.0011e-04 - learning_rate: 1.6677e-04\n", + "Epoch 183/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 272ms/step - loss: 4.3960e-04 - val_loss: 5.0021e-04 - learning_rate: 1.6677e-04\n", + "Epoch 184/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 232ms/step - loss: 4.3953e-04 - val_loss: 5.0016e-04 - learning_rate: 1.6677e-04\n", + "Epoch 185/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 304ms/step - loss: 4.3944e-04 - val_loss: 5.0004e-04 - learning_rate: 1.6677e-04\n", + "Epoch 186/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.3934e-04 - val_loss: 5.0023e-04 - learning_rate: 1.6677e-04\n", + "Epoch 187/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.3929e-04 - val_loss: 5.0016e-04 - learning_rate: 1.6677e-04\n", + "Epoch 188/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 303ms/step - loss: 4.3921e-04 - val_loss: 5.0022e-04 - learning_rate: 1.6677e-04\n", + "Epoch 189/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 232ms/step - loss: 4.3918e-04 - val_loss: 5.0015e-04 - learning_rate: 1.6677e-04\n", + "Epoch 190/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 229ms/step - loss: 4.3907e-04\n", + "Epoch 190: ReduceLROnPlateau reducing learning rate to 0.00015009464841568844.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 233ms/step - loss: 4.3907e-04 - val_loss: 5.0011e-04 - learning_rate: 1.6677e-04\n", + "Epoch 191/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 302ms/step - loss: 4.3895e-04 - val_loss: 5.0040e-04 - learning_rate: 1.5009e-04\n", + "Epoch 192/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 231ms/step - loss: 4.3894e-04 - val_loss: 5.0044e-04 - learning_rate: 1.5009e-04\n", + "Epoch 193/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 305ms/step - loss: 4.3883e-04 - val_loss: 5.0039e-04 - learning_rate: 1.5009e-04\n", + "Epoch 194/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.3876e-04 - val_loss: 5.0040e-04 - learning_rate: 1.5009e-04\n", + "Epoch 195/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.3869e-04 - val_loss: 5.0044e-04 - learning_rate: 1.5009e-04\n", + "Epoch 196/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 311ms/step - loss: 4.3865e-04 - val_loss: 5.0039e-04 - learning_rate: 1.5009e-04\n", + "Epoch 197/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 232ms/step - loss: 4.3856e-04 - val_loss: 5.0040e-04 - learning_rate: 1.5009e-04\n", + "Epoch 198/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 232ms/step - loss: 4.3849e-04 - val_loss: 5.0040e-04 - learning_rate: 1.5009e-04\n", + "Epoch 199/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 305ms/step - loss: 4.3842e-04 - val_loss: 5.0035e-04 - learning_rate: 1.5009e-04\n", + "Epoch 200/200\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 228ms/step - loss: 4.3835e-04\n", + "Epoch 200: ReduceLROnPlateau reducing learning rate to 0.0001350851875031367.\n", + "\u001b[1m72/72\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 231ms/step - loss: 4.3835e-04 - val_loss: 5.0045e-04 - learning_rate: 1.5009e-04\n" + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=200,\n", + " \n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def hungarian_loss_for_two_hits_vectorized(y_true, y_pred):\n", + "# \"\"\"\n", + "# Permutation-invariant loss for a tile with up to 2 hits, vectorized version.\n", + " \n", + "# y_true, y_pred: (batch_size, 2, 2)\n", + "# - y_true[i] has up to 2 hits, with zero-padding for empty slots.\n", + "# - y_pred[i] is the model's 2 predicted points.\n", + "# Returns: scalar (averaged loss across the batch).\n", + "# \"\"\"\n", + "\n", + "# # 1) Identify how many hits per tile\n", + "# # row_nonzero[i,j] = True if y_true[i,j] != (0,0)\n", + "# row_nonzero = tf.reduce_any(tf.not_equal(y_true, 0.0), axis=-1) # (batch_size, 2)\n", + "# num_hits = tf.reduce_sum(tf.cast(row_nonzero, tf.float32), axis=-1) # (batch_size,), values ∈ {0,1,2}\n", + "\n", + "# # 2) Create masks for 0-hit, 1-hit, 2-hit tiles\n", + "# mask_0 = tf.equal(num_hits, 0.0) # (batch_size,)\n", + "# mask_1 = tf.equal(num_hits, 1.0) # (batch_size,)\n", + "# mask_2 = tf.equal(num_hits, 2.0) # (batch_size,)\n", + "\n", + "# mask_0_f = tf.cast(mask_0, tf.float32)\n", + "# mask_1_f = tf.cast(mask_1, tf.float32)\n", + "# mask_2_f = tf.cast(mask_2, tf.float32)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 0 HITS: Force both predicted points to be (0,0).\n", + "# # -------------------------------------------------------------------------\n", + "# # cost0[i] = sum of squares of y_pred[i], i.e. (pred1^2 + pred2^2)\n", + "# cost0 = tf.reduce_sum(tf.square(y_pred), axis=[1, 2]) # (batch_size,)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 2 HITS: Permutation-invariant cost.\n", + "# # -------------------------------------------------------------------------\n", + "# # cost_1 corresponds to (hit1→pred1, hit2→pred2)\n", + "# dist_1_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 0, :]), axis=-1)\n", + "# dist_1_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 1, :]), axis=-1)\n", + "# cost_1 = dist_1_1 + dist_1_2\n", + "\n", + "# # cost_2 corresponds to (hit1→pred2, hit2→pred1)\n", + "# dist_2_1 = tf.reduce_sum(tf.square(y_true[:, 0, :] - y_pred[:, 1, :]), axis=-1)\n", + "# dist_2_2 = tf.reduce_sum(tf.square(y_true[:, 1, :] - y_pred[:, 0, :]), axis=-1)\n", + "# cost_2 = dist_2_1 + dist_2_2\n", + "\n", + "# # Pick the smaller permutation cost\n", + "# cost2 = tf.minimum(cost_1, cost_2) # (batch_size,)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # CASE 1 HIT:\n", + "# # - Identify which row is the real hit (row0 or row1).\n", + "# # - Compute MSE for matching that hit to whichever predicted row is closer.\n", + "# # - Penalize the other predicted row for not being (0,0).\n", + "# # -------------------------------------------------------------------------\n", + "# row0_is_hit = row_nonzero[:, 0] # (batch_size,)\n", + "# # ground-truth single hit => either tile_true[:,0,:] or tile_true[:,1,:]\n", + "# gt_hit = tf.where(\n", + "# tf.expand_dims(row0_is_hit, axis=-1),\n", + "# y_true[:, 0, :],\n", + "# y_true[:, 1, :]\n", + "# ) # (batch_size, 2)\n", + "\n", + "# # Distances to each predicted point\n", + "# dist_pred_0 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 0, :]), axis=-1)\n", + "# dist_pred_1 = tf.reduce_sum(tf.square(gt_hit - y_pred[:, 1, :]), axis=-1)\n", + "\n", + "# # Also penalize the other row for not being near (0,0).\n", + "# zero_cost_0 = tf.reduce_sum(tf.square(y_pred[:, 0, :]), axis=-1)\n", + "# zero_cost_1 = tf.reduce_sum(tf.square(y_pred[:, 1, :]), axis=-1)\n", + "\n", + "# # Two ways to match:\n", + "# # -- pred_0 is the real hit => dist_pred_0 + zero_cost_1\n", + "# # -- pred_1 is the real hit => dist_pred_1 + zero_cost_0\n", + "# cost_if_0_matched = dist_pred_0 + zero_cost_1\n", + "# cost_if_1_matched = dist_pred_1 + zero_cost_0\n", + "# cost1 = tf.minimum(cost_if_0_matched, cost_if_1_matched) # (batch_size,)\n", + "\n", + "# # -------------------------------------------------------------------------\n", + "# # Combine costs across all tiles\n", + "# # For each tile i, only one of mask_0, mask_1, mask_2 is True.\n", + "# # -------------------------------------------------------------------------\n", + "# total_cost = mask_0_f * cost0 + mask_1_f * cost1 + mask_2_f * cost2\n", + "\n", + "# # Average over the batch\n", + "# loss = tf.reduce_mean(total_cost)\n", + "# return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# model.save('/home/da886/Computer Vision_Object Detection/Trained_Weights/20KFixed_10_256by256_RandomindexNoNoise_linear_HungarianLoss_with metrics_4x4.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Computer Vision_Object Detection/Trained_Weights/10KFixed_100_256by256_95indexNoNoise_linear_custom_HungarianLoss.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 4.4143e-04 \n" + ] + } + ], + "source": [ + "results = model.evaluate(val_dataset)\n", + "# print(\"Loss:\", results[0])\n", + "# print(\"0-hit cost:\", results[1])\n", + "# print(\"1-hit cost:\", results[2])\n", + "# print(\"2-hit cost:\", results[3])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m640/640\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 700us/step\n", + "Predicted centers shape: (30, 1024, 2, 2)\n", + "Grouped targets shape: (20, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "# # # Flatten validation images and centers\n", + "# val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "# val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "\n", + "# Batch size for n images\n", + "batch = 20* 1024 # number of images per batch\n", + "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch)\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch)\n", + "# Make predictions on dataset\n", + "# inputs, targets = next(iter(val_dataset)) # Extract a batch\n", + "inputs, targets = next(iter(train_dataset)) # Extract a batch\n", + "outputs = model.predict(inputs)\n", + "\n", + "# Reshape predictions and targets back to image structure\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 2)\n", + "\n", + "# Print the shapes\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\") # (batch_size // 1024, 1024, 2, 2)\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\") # (batch_size // 1024, 1024, 2, 2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 7:\n", + "Tile 0: Predicted: [[ 4.2933702e-01 4.5094854e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 4: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 5: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 6: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 7: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 11: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-6.4222937 0.37683845]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[ 0.30674583 -6.543586 ]\n", + " [ 0.6341724 0.6660101 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 18: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-6.130267 0.00758261]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[-0.02358457 -6.2122993 ]\n", + " [ 0.29561207 0.2604496 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 23: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 24: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 28: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 29: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 30: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 31: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 34: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 35: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 37: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 38: Predicted: [[-6.889794 0.10115233]\n", + " [ 0.12848419 -6.856407 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[ 6.7292303e-01 6.8793648e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-5.996009 0.25887933]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[ 0.2584858 -6.0589857 ]\n", + " [ 0.85040736 0.81449914]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 44: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 46: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 48: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 49: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 51: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 53: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 55: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 59: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 61: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 63: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 64: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 65: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 66: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 67: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 68: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 69: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 71: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 73: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 76: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 77: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 80: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 85: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 86: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 87: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-3.8521085 0.61414737]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 88: Predicted: [[ 0.59579355 -4.063755 ]\n", + " [ 0.8864118 0.88839096]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 90: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 91: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 92: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 93: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 95: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 96: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 98: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 99: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 100: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 102: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 103: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 106: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.75 0.75]\n", + " [0. 0. ]]\n", + "Tile 108: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-2.5732553 0.32510072]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[ 0.256521 -2.6821606 ]\n", + " [ 0.5734639 0.54866827]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 111: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 112: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 113: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 114: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 118: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 119: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 120: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 122: Predicted: [[-8.700562 0.4255376]\n", + " [ 0.365371 -8.867544 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[ 8.4070486e-01 8.5083073e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 124: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 126: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 127: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 129: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 131: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-11.425696 0.07899522]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[ 0.01336128 -11.448276 ]\n", + " [ 0.47868663 0.46239245]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 134: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 140: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 141: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 142: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 143: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 145: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 147: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 149: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 151: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 155: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 160: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 161: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 162: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 164: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 165: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 166: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 167: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 169: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[-3.3402421 0.08005365]\n", + " [ 0.07467461 -3.4393053 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 171: Predicted: [[ 5.0495005e-01 4.9363285e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 172: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 174: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 179: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 180: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 182: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 184: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 186: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 188: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 190: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[-3.7368207 0.17293486]\n", + " [ 0.1999774 -3.900772 ]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 192: Predicted: [[ 6.2387431e-01 6.0841101e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 194: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 196: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 198: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 199: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 201: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 202: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-14.564935 0.0630294]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 205: Predicted: [[ 0.01611656 -14.533134 ]\n", + " [ 0.5662236 0.59336054]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 206: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 207: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 210: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 211: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 212: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 213: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 214: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 215: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 216: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 217: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 218: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 219: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 220: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 222: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 225: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 226: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 227: Predicted: [[-6.1115108 0.19076128]\n", + " [ 0.14094907 -5.9475255 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 228: Predicted: [[ 6.8657571e-01 7.0527411e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 230: Predicted: [[-4.9106364 0.09501535]\n", + " [ 0.07906967 -4.7813535 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 231: Predicted: [[ 0.37090492 0.3436619 ]\n", + " [-9.278201 0.42952073]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[ 0.36161435 -9.515223 ]\n", + " [ 0.71379197 0.7985379 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[-11.201218 0.14513382]\n", + " [ 0.07667345 -11.142998 ]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 234: Predicted: [[ 6.0651290e-01 6.2496358e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 236: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 237: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 238: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 239: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 240: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 241: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 242: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 244: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 245: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 246: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 247: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 249: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 253: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 254: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 255: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 257: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 258: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 259: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 262: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 264: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 266: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 267: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-7.8524165 0.27515253]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 268: Predicted: [[ 0.20024711 -8.050455 ]\n", + " [ 0.60607535 0.70006394]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 272: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 273: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 274: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 278: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 279: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 280: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 281: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 283: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 284: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 286: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 287: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 288: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 290: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 291: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 292: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 293: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 294: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 295: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 296: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 297: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 298: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 299: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 300: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 302: Predicted: [[-3.9653337 0.3070139 ]\n", + " [ 0.24530852 -4.1018157 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 303: Predicted: [[ 5.9244239e-01 5.7438880e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 304: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 305: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 307: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 309: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 310: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 311: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 313: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 314: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 315: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 317: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 318: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 320: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 321: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-6.8543305 0.60152024]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[ 0.5523726 -7.008891 ]\n", + " [ 0.7527702 0.7225194]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[-6.8139753 0.16075584]\n", + " [ 0.0726437 -6.664028 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[ 0.7296856 0.7762922 ]\n", + " [-5.069298 0.18078887]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 325: Predicted: [[ 0.1963419 -5.1658664 ]\n", + " [ 0.7252784 0.70324755]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-3.708979 0.08916619]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 328: Predicted: [[ 0.10153762 -3.6626039 ]\n", + " [ 0.5592919 0.51373184]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 330: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 333: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 334: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 336: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 337: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 338: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 339: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 340: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 342: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 344: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 345: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 347: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 349: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 350: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 351: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 353: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 354: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 355: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 356: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 362: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 365: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 366: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 367: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 369: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 370: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 371: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 372: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 374: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 375: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[-10.954488 0.17638299]\n", + " [ 0.11449331 -10.896125 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 378: Predicted: [[ 5.8947188e-01 6.1689192e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 380: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 381: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 382: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 383: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 384: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 385: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 386: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 388: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 389: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 393: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 395: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 396: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 397: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 398: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 399: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 405: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 407: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 408: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 411: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 412: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 414: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-8.367105 0.32455638]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[ 0.2694465 -8.567538 ]\n", + " [ 0.5999821 0.69944006]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 416: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 419: Predicted: [[-6.0898409e+00 2.5177129e-02]\n", + " [ 4.8767328e-03 -6.1777673e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[ 0.35784495 0.3079248 ]\n", + " [-6.113611 0.41466433]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[ 0.32794398 -6.252963 ]\n", + " [ 0.85820234 0.85473526]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 423: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 424: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 425: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 429: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 437: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 441: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 443: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[-0.29594332 0.3354839 ]\n", + " [ 0.2971822 -0.39757493]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[ 4.7500476e-01 5.0282592e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 449: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 451: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[-7.731839 0.14114752]\n", + " [ 0.2032761 -7.942536 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 453: Predicted: [[ 0.8407501 0.8522405 ]\n", + " [-4.0211086 0.18337896]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 454: Predicted: [[ 0.20086822 -4.189863 ]\n", + " [ 0.69143957 0.69346017]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 457: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 458: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 459: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-8.294123 -0.05424104]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 460: Predicted: [[-0.06950498 -8.394635 ]\n", + " [ 0.41394594 0.39061785]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 462: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 466: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 467: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 468: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 469: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 470: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 471: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 472: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 478: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 481: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 482: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 483: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 486: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 487: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 490: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 492: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 493: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 495: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 496: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 497: Predicted: [[-8.699165 0.02763711]\n", + " [-0.06664932 -8.714999 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[ 4.9577969e-01 5.2634060e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 499: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 500: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-7.1663275 0.0482639]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[-0.01382631 -7.107813 ]\n", + " [ 0.5542907 0.6311254 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 505: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.5 0. ]\n", + " [0.125 0.5 ]]\n", + "Tile 507: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 509: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-11.560972 0.32099637]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[ 0.3044595 -11.557535 ]\n", + " [ 0.8289847 0.74041796]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 512: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 513: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-11.550409 0.80159146]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[ 0.7416738 -11.757994 ]\n", + " [ 0.73126876 0.75301224]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 517: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 519: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 522: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 523: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 524: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 526: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[-1.3723572 0.30169648]\n", + " [ 0.3312728 -1.633231 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[ 0.66272026 0.6624689 ]\n", + " [-6.4408565 0.12087957]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 529: Predicted: [[ 0.00854531 -6.3874664 ]\n", + " [ 0.6031848 0.6064178 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 530: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 535: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 536: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-2.6254513 0.09877803]], True: [[0.25 0. ]\n", + " [0.875 0. ]]\n", + "Tile 538: Predicted: [[ 0.12907165 -2.7472389 ]\n", + " [ 0.46201375 0.39485508]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 542: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 543: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 544: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 548: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 549: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 552: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-9.090619 0.41935673]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[ 0.34056658 -9.17527 ]\n", + " [ 0.8607005 0.89860123]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 554: Predicted: [[-15.338154 0.04747389]\n", + " [ 0.03512019 -15.311117 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[ 0.5995102 0.58928615]\n", + " [-5.0165386 0.5120578 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 556: Predicted: [[ 0.44652054 -5.2143855 ]\n", + " [ 0.5054354 0.5192408 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 558: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 560: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 561: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-7.442164 -0.05067229]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 562: Predicted: [[-0.07312506 -7.568247 ]\n", + " [ 0.37652487 0.35333818]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 563: Predicted: [[-6.292846 0.2777338]\n", + " [ 0.2090826 -6.4714584]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[ 5.9838450e-01 6.6290551e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 565: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 566: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 567: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 568: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 569: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 570: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 571: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 572: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 579: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 582: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 583: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 584: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 585: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 590: Predicted: [[-9.596779 0.19864964]\n", + " [ 0.08739328 -9.583385 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[ 5.9624982e-01 6.7930293e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 592: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 594: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 596: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 597: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 598: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[-7.644228 0.35048068]\n", + " [ 0.29179907 -7.680726 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 600: Predicted: [[ 7.6935190e-01 7.3328584e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 602: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 603: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 604: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 605: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 606: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 608: Predicted: [[-6.739223 0.12385007]\n", + " [ 0.10243389 -6.74708 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 609: Predicted: [[ 6.5051597e-01 7.0366776e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 610: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 613: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 617: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 618: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 619: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 620: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 622: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 623: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 625: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 626: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 627: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 628: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 633: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 634: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 635: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 641: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 642: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 643: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 645: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 647: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 648: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 649: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 650: Predicted: [[-8.276777 0.29002914]\n", + " [ 0.21870637 -8.4833555 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 651: Predicted: [[ 0.6036275 0.7059227 ]\n", + " [-6.477952 0.22595882]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 652: Predicted: [[ 0.20691061 -6.4919896 ]\n", + " [ 0.7509459 0.74504936]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 653: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 654: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-7.13246 0.40965265]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[ 0.42519087 -7.2190065 ]\n", + " [ 0.7484232 0.8753968 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 657: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 659: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 660: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 662: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 663: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-11.733579 0.1558398]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[ 0.15263385 -11.723225 ]\n", + " [ 0.56094843 0.5863585 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 667: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 674: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 676: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 677: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-11.012983 0.15557441]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 679: Predicted: [[ 0.05968255 -10.99023 ]\n", + " [ 0.4741662 0.4639513 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[-12.229623 0.11474379]\n", + " [ 0.10395485 -12.296809 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[ 7.7182305e-01 7.8210372e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 688: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 693: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 694: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 695: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 698: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 699: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 700: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 701: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 705: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 706: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 708: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 710: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 711: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 712: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 713: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 715: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 716: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 717: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 718: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 722: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 723: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 724: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 726: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 727: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 729: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 730: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 731: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 733: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 734: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 735: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 741: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 742: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 746: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 748: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 749: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 750: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 751: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 753: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 754: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 756: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 760: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 764: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 765: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 766: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 768: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 771: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 777: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 778: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 779: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 780: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 781: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 786: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 788: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 789: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 790: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[-8.650517 0.3562764 ]\n", + " [ 0.28725195 -8.789248 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 792: Predicted: [[ 0.6972984 0.78462327]\n", + " [-8.640137 0.39927915]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 793: Predicted: [[ 0.31041062 -8.753062 ]\n", + " [ 0.62478846 0.6739327 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 795: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 796: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 797: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 798: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 799: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 801: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 802: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[-4.6575847 0.15725255]\n", + " [ 0.16653505 -4.7379036 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[ 7.4836743e-01 7.4237585e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 805: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 806: Predicted: [[-7.9091167 0.33640093]\n", + " [ 0.31167644 -7.958471 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 807: Predicted: [[ 9.0992308e-01 8.5790014e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 808: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 809: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[-14.043821 0.0790889]\n", + " [ 0.03713 -13.994844 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 819: Predicted: [[ 5.7775891e-01 6.0166645e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 820: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 823: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 824: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 825: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 829: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 830: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 832: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 836: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 838: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 839: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 840: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 841: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 843: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.125 0.375]\n", + " [0.875 0. ]]\n", + "Tile 844: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-13.675548 0.16435146]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 847: Predicted: [[ 0.18082714 -13.621978 ]\n", + " [ 0.7209947 0.6875607 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 850: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 853: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 854: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 857: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 858: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 860: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 861: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-10.508772 0.20056173]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[ 0.08655372 -10.463393 ]\n", + " [ 0.748579 0.8181815 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 866: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 868: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[-8.634879 0.22334734]\n", + " [ 0.17170113 -8.65427 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[ 0.51509166 0.5005846 ]\n", + " [-9.509909 0.4182742 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 874: Predicted: [[ 0.36220473 -9.704557 ]\n", + " [ 0.85977155 0.8388089 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 875: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 876: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 878: Predicted: [[-9.317797 0.33329457]\n", + " [ 0.26751631 -9.40518 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 879: Predicted: [[ 8.0870795e-01 8.8400674e-01]\n", + " [-1.7282278e+01 1.6603328e-02]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 880: Predicted: [[ 0.02206773 -17.302822 ]\n", + " [ 0.6217186 0.6217596 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 883: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 885: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 886: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 887: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 888: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 889: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[-4.0822887 0.21371618]\n", + " [ 0.18820417 -4.225374 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 894: Predicted: [[ 0.64664644 0.61355907]\n", + " [-6.3722343 0.15721273]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 895: Predicted: [[ 0.13755307 -6.4656715 ]\n", + " [ 0.224365 0.26453137]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 896: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 901: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 904: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 909: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-8.751 0.05108788]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[-0.06662959 -8.769192 ]\n", + " [ 0.50255513 0.51750034]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 912: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 917: Predicted: [[-8.387134 0.29176858]\n", + " [ 0.20493752 -8.62697 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 918: Predicted: [[ 5.4334480e-01 6.2942719e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 919: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 920: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 921: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-8.353215 -0.05035079]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 922: Predicted: [[-0.10396147 -8.297645 ]\n", + " [ 0.27533942 0.39028907]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 923: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 924: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-8.265967 -0.08429886]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[-0.07388273 -8.193624 ]\n", + " [ 0.13009723 0.16137335]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[-12.015714 0.0251034 ]\n", + " [ -0.06083268 -11.878369 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[ 5.6379628e-01 6.1710942e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 928: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 930: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-6.649015 0.15902612]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[ 0.10976648 -6.508948 ]\n", + " [ 0.653485 0.66969967]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 935: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 937: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 938: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 941: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 942: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 944: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 948: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 949: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 951: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 953: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 954: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 956: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 957: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 959: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 962: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 964: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 965: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 966: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-13.174749 0.09265139]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 967: Predicted: [[ 0.03738302 -13.11851 ]\n", + " [ 0.5764839 0.6082117 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[-1.4781432 0.5102564 ]\n", + " [ 0.51798177 -1.7280761 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 969: Predicted: [[ 6.6108418e-01 6.7234868e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 970: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.875 0. ]\n", + " [0. 0. ]]\n", + "Tile 974: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 976: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[-5.194894 0.37870473]\n", + " [ 0.4266945 -5.3791785 ]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 978: Predicted: [[ 6.7231929e-01 6.8958974e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 979: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 980: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 982: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 984: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 987: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 988: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-7.3713646 0.11137689]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[ 0.07116854 -7.2675896 ]\n", + " [ 0.5984247 0.6632407 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 992: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 995: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 996: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1001: Predicted: [[-1.1282418e+01 6.4327069e-02]\n", + " [-7.8588724e-04 -1.1294048e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1002: Predicted: [[ 5.0020176e-01 4.9711925e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1004: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1005: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1006: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1008: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1009: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 1012: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 1014: Predicted: [[ 6.3074827e-01 6.4264202e-01]\n", + " [-1.7917027e+01 -6.0782954e-03]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1015: Predicted: [[ 8.3753467e-03 -1.7968706e+01]\n", + " [ 6.3074827e-01 6.4264202e-01]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1016: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.625 0.625]\n", + " [0.5 0.625]]\n", + "Tile 1017: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-6.889794 0.10115233]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[ 0.12848419 -6.856407 ]\n", + " [ 0.672923 0.6879365 ]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1019: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 1020: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-5.590482 0.08839907]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 1021: Predicted: [[ 0.06288812 -5.4572144 ]\n", + " [ 0.32688683 0.27241513]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1022: Predicted: [[-1.7917027e+01 -6.0782954e-03]\n", + " [ 8.3753467e-03 -1.7968706e+01]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 1023: Predicted: [[ 0.6307483 0.642642 ]\n", + " [-8.623062 0.06508761]], True: [[0.75 0.75]\n", + " [0. 0. ]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "image_index = np.random.randint(0, 20) # Randomly pick an image in the batch\n", + "# image_index = 0\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 62\n", + "False Positives (FP): 724\n", + "False Negatives (FN): 37\n", + "Precision: 0.0789, Recall: 0.6263\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "\n", + "threshold = 0.8 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits): \n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1* tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 99\n", + "False Positives (FP): 16\n", + "False Negatives (FN): 0\n", + "Precision: 0.8609, Recall: 1.0000\n" + ] + } + ], + "source": [ + "\n", + "\n", + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.8\n", + "tile_size = 8\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " matched_true_hits = set()\n", + " matched_predictions = set()\n", + "\n", + " for pred_idx, pred in enumerate(valid_predicted_hits):\n", + " if pred_idx in matched_predictions:\n", + " continue\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1 *tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " matched_predictions.add(pred_idx)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# # Example usage\n", + "# tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "# reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# # Plotting\n", + "# fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "# for i in range(4):\n", + "# ax[i].imshow(tiles[i], cmap='gray')\n", + "# ax[i].set_title(f\"Tile {i}\")\n", + "# ax[i].axis('off')\n", + "\n", + "# ax[4].imshow(reconstructed_image, cmap='gray')\n", + "# ax[4].set_title(\"Reconstructed Image\")\n", + "# ax[4].axis('off')\n", + "\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.8):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "c = np.random.randint(0,20)\n", + "image_index = c # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First image's first tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n", + "First image's second tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "for val_images, val_centers in val_dataset.take(1):\n", + " print(\"First image's first tile:\")\n", + " print(val_images[2, 0]) # Tile 0 of Image 0\n", + " print(\"First image's second tile:\")\n", + " print(val_images[2, 1]) # Tile 1 of Image 0\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ComputerVision_OD_Electron_Counting/Dataset_Generator.ipynb b/ComputerVision_OD_Electron_Counting/Dataset_Generator.ipynb new file mode 100644 index 0000000..c63a537 --- /dev/null +++ b/ComputerVision_OD_Electron_Counting/Dataset_Generator.ipynb @@ -0,0 +1,342 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating images: 100%|██████████| 50000/50000 [00:35<00:00, 1425.32it/s]\n", + "Generating noise-only images: 0it [00:00, ?it/s]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import random\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "import h5py\n", + "\n", + "class ImageProcessor:\n", + " \"\"\"Image generation class\"\"\" \n", + " \n", + " def __init__(self, \n", + " num_to_generate,\n", + " tiff_path, \n", + " dark_noise_path, \n", + " canvas_size = (256, 256), \n", + " max_electron_hits = 100):\n", + " \"\"\"Initializes the ImageProcessor class\n", + "\n", + " Args:\n", + " num_to_generate (int): Number of images to generate\n", + " tiff_path (str): Location of the tiff file that contains the electron hits\n", + " dark_noise_path (str): Path to the noisy data\n", + " canvas_size (tuple, optional): Size of the canvas to place the images on. Defaults to (64, 64).\n", + " max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 13.\n", + " \"\"\" \n", + " \n", + " self.tiff_path = tiff_path\n", + " self.dark_noise_path = dark_noise_path\n", + " self.canvas_size = canvas_size\n", + " self.num_to_generate = num_to_generate\n", + " self.max_electron_hits = max_electron_hits\n", + " \n", + " # Loads the images from the tiff file\n", + " self.images = self.load_images_from_tiff(tiff_path)\n", + " self.dark_noise_images = self.load_images_from_tiff(dark_noise_path)\n", + " \n", + " # Creates a dark stack of the same size as the canvas\n", + " self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + " \n", + " def load_images_from_tiff(self, tiff_path):\n", + " \"\"\"Loads the images from a tiff file\n", + "\n", + " Args:\n", + " tiff_path (str): Path to the tiff file\n", + "\n", + " Returns:\n", + " list: List of images\n", + " \"\"\" \n", + " with Image.open(tiff_path) as img:\n", + " images = []\n", + " for i in range(img.n_frames):\n", + " img.seek(i)\n", + " images.append(np.array(img))\n", + " return images\n", + " \n", + " def noisy(self, noise_typ, image): \n", + " \"\"\"Adds noise to the images\n", + " \n", + " Args:\n", + " noise_typ (str): Type of noise to add\n", + " image (numpy array): Image to add noise to\n", + " \n", + " Returns:\n", + " numpy array: Noisy image\n", + " \"\"\"\n", + " if noise_typ == \"gauss\":\n", + " row, col = image.shape\n", + " mean = 0\n", + " var = 0.0001\n", + " sigma = var ** 0.5\n", + " threshold = 8\n", + " gauss = np.random.normal(mean, sigma, (row, col))\n", + " tnoisy = image + gauss\n", + "\n", + " tnoisy[tnoisy < threshold] = 0\n", + " noisy = np.round(tnoisy)\n", + " return noisy\n", + "\n", + " def deadcorr(self, image):\n", + " \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\n", + " \n", + " Args:\n", + " image (numpy array): Image to correct\n", + " \"\"\" \n", + " temp = image.copy()\n", + " temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + " return temp\n", + "\n", + " def dark_stack(self, imgsize):\n", + " \"\"\"Creates a dark stack of the same size as the canvas.\n", + " \n", + " Args:\n", + " imgsize (int): Size of the images in the stack\n", + " \"\"\" \n", + " dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + " dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + " return dark_noise_stack_cropped\n", + "\n", + " \n", + " def place_image_on_canvas(self):\n", + " \"\"\"Places the electron hits on the canvas without specifying intensity range.\"\"\"\n", + " canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + " height, width = self.images[0].shape\n", + " max_x = self.canvas_size[1]\n", + " max_y = self.canvas_size[0]\n", + " centers = []\n", + " centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + " \n", + " for i in range(self.max_electron_hits):\n", + " x = random.randint(1 - width//2, max_x - width//2 - 1)\n", + " y = random.randint(1 - height//2, max_y - height//2 - 1)\n", + " \n", + " # Randomly select an electron hit\n", + " index = random.randint(0, 97999)\n", + " # index = 95\n", + " hit = self.images[index]\n", + " \n", + " y_min = y\n", + " y_max = y + height\n", + " x_min = x \n", + " x_max = x + width\n", + " \n", + " x_center = x + width // 2 # Correct the center calculation to be the true midpoint\n", + " y_center = y + height // 2 # Correct the center calculation to be the true midpoint\n", + " \n", + " if y_min < 0:\n", + " hit = hit[y_min*-1:, :]\n", + " y_min = 0\n", + "\n", + " if y_max > max_y:\n", + " hit = hit[:-(y_max-max_y), :]\n", + " y_max = max_y\n", + " \n", + " if x_min < 0:\n", + " hit = hit[:, x_min*-1:]\n", + " x_min = 0\n", + " \n", + " if x_max > max_x:\n", + " hit = hit[:, :-(x_max-max_x)]\n", + " x_max = max_x\n", + " \n", + " # canvas[y_min:y_max, x_min:x_max] = hit\n", + " canvas[y_min:y_max, x_min:x_max]=np.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255)\n", + " centers.append((x_center, y_center))\n", + " centers_training[i, 0] = 1\n", + " centers_training[i, 1:] = [x_center, y_center]\n", + " \n", + " # # Apply Gaussian noise\n", + " # canvas = self.noisy('gauss', canvas)\n", + " # noise_int = np.random.randint(len(self.dark_noise))\n", + " # canvas = canvas + self.dark_noise[noise_int]\n", + " canvas = canvas \n", + " \n", + " return (canvas, centers, centers_training)\n", + "\n", + " \n", + " def generate_multiple_images(self):\n", + " \"\"\"Generates multiple images without specifying intensity range for the objects.\"\"\" \n", + " results = []\n", + " for _ in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + " results.append(self.place_image_on_canvas())\n", + " return results\n", + "\n", + " \n", + " def generate_noise_only_images(self, num_images):\n", + " \"\"\"Generates images containing only noise, with no electron hits.\n", + "\n", + " Args:\n", + " num_images (int): Number of noise-only images to generate.\n", + "\n", + " Returns:\n", + " list: List of generated noise-only images.\n", + " \"\"\"\n", + " noise_images = []\n", + " for _ in tqdm(range(num_images), desc=\"Generating noise-only images\"):\n", + " # Create an empty canvas\n", + " canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "\n", + " # Apply Gaussian noise\n", + " canvas = self.noisy('gauss', canvas)\n", + "\n", + " # Add dark noise\n", + " noise_int = np.random.randint(len(self.dark_noise))\n", + " canvas = canvas + self.dark_noise[noise_int]\n", + "\n", + " noise_images.append(canvas)\n", + "\n", + " return noise_images\n", + " \n", + " def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + " \"\"\"Mixes object-containing images with noise-only images and saves to an HDF5 file\n", + " \n", + " Args:\n", + " data_with_objects (list): List of data with objects to save.\n", + " noise_images (list): List of noise-only images to save.\n", + " filename (str): Path to the HDF5 file.\n", + " \"\"\"\n", + " total_images = len(data_with_objects) + len(noise_images)\n", + " combined_data = []\n", + "\n", + " # Add labels: 1 for images with objects, 0 for noise-only images\n", + " for item in data_with_objects:\n", + " combined_data.append((item[0], item[2], 1)) # 1 indicates it contains objects\n", + " \n", + " for noise_image in noise_images:\n", + " combined_data.append((noise_image, np.zeros((100, 3)), 0)) # 0 indicates noise-only\n", + " \n", + " # Shuffle the combined data\n", + " random.shuffle(combined_data)\n", + "\n", + " # Save to HDF5 file\n", + " with h5py.File(filename, 'w') as h5_file:\n", + " theimages = h5_file.create_dataset('images', shape=(total_images, 256, 256), dtype='uint8')\n", + " thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 100, 3), dtype='float32')\n", + " labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + " for i, (image, center, label) in enumerate(combined_data):\n", + " theimages[i] = image\n", + " thecenters[i] = center\n", + " labels[i] = label\n", + "\n", + "\n", + "tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# Creating an instance of ImageProcessor\n", + "processor = ImageProcessor(50000, tiff_path, dark_noise_path, max_electron_hits=100)\n", + "\n", + "# Generating images with objects \n", + "data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# Generating noise-only images\n", + "noise_only_images = processor.generate_noise_only_images(0)\n", + "\n", + "# Save mixed dataset to an HDF5 file\n", + "processor.save_mixed_images_to_h5(data_with_intensity_range, noise_only_images, '/home/da886/ComputerVision_OD_Electron_Counting/Images_and_Labels/50KFixed_100_256by256_RandomindexNoNoise.h5')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tifffile as tiff\n", + "import os\n", + "\n", + "# Load the TIFF stack\n", + "file_path = '/home/m3-learning/Documents/myML/200kV_98000electron.tif'\n", + "tiff_stack = tiff.imread(file_path)\n", + "\n", + "# Check the shape of the stack to ensure it is a 3D array\n", + "print(tiff_stack.shape) # (num_slices, height, width)\n", + "\n", + "# Verify the shape\n", + "if len(tiff_stack.shape) != 3:\n", + " raise ValueError(\"The loaded TIFF stack is not a 3D array.\")\n", + "\n", + "# Function to plot multiple slices in a grid\n", + "def plot_slices(start, end):\n", + " fig, axes = plt.subplots(nrows=10, ncols=10, figsize=(15, 15))\n", + " fig.suptitle(f'Slices {start} to {end-1}')\n", + " \n", + " for i, ax in enumerate(axes.flat):\n", + " slice_index = start + i\n", + " if slice_index < end:\n", + " ax.imshow(tiff_stack[slice_index], cmap='gray')\n", + " ax.set_title(f'Slice {slice_index}')\n", + " ax.axis('off')\n", + " else:\n", + " ax.axis('off')\n", + " \n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.95)\n", + " plt.show()\n", + "\n", + "# Plot the first 100 slices\n", + "plot_slices(7899, 7999)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ObjectDetection", + "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.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ComputerVision_OD_Electron_Counting/Receptive_Field.ipynb b/ComputerVision_OD_Electron_Counting/Receptive_Field.ipynb new file mode 100644 index 0000000..cb0f777 --- /dev/null +++ b/ComputerVision_OD_Electron_Counting/Receptive_Field.ipynb @@ -0,0 +1,1015 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6b5a6fcd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 16:50:49.828262: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-05-03 16:50:49.840705: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1746305449.853454 706921 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1746305449.857346 706921 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1746305449.868367 706921 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1746305449.868383 706921 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1746305449.868385 706921 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1746305449.868386 706921 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2025-05-03 16:50:49.871876: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:5',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I0000 00:00:1746305451.875549 706921 gpu_device.cc:2019] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:c5:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\" # Only GPUs 6 and 7 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:5\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "534e7c3e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "05c9821e", + "metadata": {}, + "outputs": [], + "source": [ + "import h5py, numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ─── geometry constants ─────────────────────────────────────────\n", + "IMAGE_SIZE = 256\n", + "GRID = 128\n", + "STRIDE = 2\n", + "RF_SIZE = 8\n", + "OFFSET = RF_SIZE // 2 # 4\n", + "MAX_HITS = 4\n", + "# ────────────────────────────────────────────────────────────────\n", + "\n", + "def build_label(hit_array: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " hit_array: (M,3) rows = [id, x_px, y_px] in 64×64 coords\n", + " returns : (32,32,MAX_HITS,3) with slots [p, nx, ny]\n", + " \"\"\"\n", + " lbl = np.zeros((GRID, GRID, MAX_HITS, 3), dtype=np.float32)\n", + " slot_idx = np.zeros((GRID, GRID), dtype=np.int8)\n", + "\n", + " for _i, x_px, y_px in hit_array:\n", + " # 1) which output cell\n", + " c = int(x_px // STRIDE)\n", + " r = int(y_px // STRIDE)\n", + " if not (0 <= r < GRID and 0 <= c < GRID):\n", + " continue\n", + "\n", + " k = slot_idx[r, c]\n", + " if k >= MAX_HITS:\n", + " continue\n", + "\n", + " # 2) top‐left of this RF in input space\n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + "\n", + " # 3) local normalised coords\n", + " nx = (x_px - x0) / RF_SIZE\n", + " ny = (y_px - y0) / RF_SIZE\n", + " # nx = np.clip(nx, 0.0, 1)\n", + " # ny = np.clip(ny, 0.0, 1)\n", + "\n", + " # 4) write slot\n", + " lbl[r, c, k, 0] = 1.0\n", + " lbl[r, c, k, 1] = nx\n", + " lbl[r, c, k, 2] = ny\n", + " slot_idx[r, c] += 1\n", + "\n", + " return lbl\n", + "\n", + "\n", + "def load_dataset(h5_path: str, max_samples: int = None):\n", + " \"\"\"Returns X:(N,64,64,1), y:(N,32,32,MAX_HITS,3)\"\"\"\n", + " with h5py.File(h5_path, \"r\") as f:\n", + " imgs = np.asarray(f[\"images\"][:max_samples], np.float32)\n", + " centers = np.asarray(f[\"centers_training\"][:max_samples]) # (N,M,3)\n", + "\n", + " # normalize + add channel\n", + " X = imgs / (imgs.max() + 1e-7)\n", + " X = X[..., None] # (N,64,64,1)\n", + "\n", + " # build per‐frame label\n", + " y = np.stack([build_label(hits) for hits in centers], axis=0)\n", + " # y.shape == (N,32,32,MAX_HITS,3)\n", + "\n", + " return X, y\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c4d5037e", + "metadata": {}, + "outputs": [], + "source": [ + "h5_file = \"/home/da886/ComputerVision_OD_Electron_Counting/Images_and_Labels/50KFixed_100_256by256_RandomindexNoNoise.h5\"\n", + "X_images,y_labels = load_dataset(h5_file, max_samples=10000) " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c0c76472", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: (9500, 256, 256, 1) (9500, 128, 128, 4, 3)\n", + " Val : (500, 256, 256, 1) (500, 128, 128, 4, 3)\n" + ] + } + ], + "source": [ + "X_train, X_val, y_train, y_val = train_test_split(\n", + " X_images, y_labels,\n", + " test_size=0.05,\n", + " random_state=42,\n", + " shuffle=True\n", + ")\n", + "\n", + "print(\"Train:\", X_train.shape, y_train.shape)\n", + "print(\" Val :\", X_val.shape, y_val.shape)\n", + "\n", + "# 3) Build tf.data pipelines\n", + "batch_size = 128\n", + "\n", + "train_ds = (\n", + " tf.data.Dataset\n", + " .from_tensor_slices((X_train, y_train))\n", + " .shuffle(buffer_size=len(X_train), seed=42)\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE)\n", + ")\n", + "\n", + "val_ds = (\n", + " tf.data.Dataset\n", + " .from_tensor_slices((X_val, y_val))\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "794b6532", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def gating_spatial(tensor):\n", + " raw_p = tensor[..., 0] # (B,H,W,K)\n", + " xy = tensor[..., 1:3] # (B,H,W,K,2)\n", + " \n", + " p = tf.sigmoid(raw_p)[...,None]\n", + " # gate = tf.cast(p > 0.5, tf.float32) # ← this is non-diff\n", + " # xy_g = xy * gate\n", + " xy_g = xy * p\n", + " return tf.concat([p, xy_g], axis=-1)\n", + "\n", + "def create_rf8_detector(input_shape=(256,256,1), max_hits=4):\n", + " inp = layers.Input(shape=input_shape)\n", + "\n", + " \n", + " x = layers.Conv2D(128, 3, padding='same', activation='relu')(inp) # RF→3, J→1\n", + " x = layers.Conv2D(128, 3, padding='same', activation='relu')(x) # RF→5, J→1\n", + " x = layers.Conv2D(128, 3, padding='same', activation='relu')(x) # RF→7, J→1\n", + " x = layers.MaxPooling2D(2, padding='same')(x) \n", + "\n", + " \n", + " x = layers.Conv2D(max_hits*3, 1, padding='same')(x)\n", + " x = layers.Reshape((128,128,max_hits,3))(x)\n", + " out = layers.Lambda(gating_spatial)(x)\n", + " \n", + " return Model(inp, out, name=\"RF8_Detector\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "e0838934", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from itertools import permutations\n", + "\n", + "# ─── Hyper‑params (tune if needed) ──────────────────────────────\n", + "K = 4 # number of slots per RF\n", + "POS_W = 2.0 # weight for positive examples in BCE\n", + "LAMBDA_XY= 3.0 # weight for coordinate loss\n", + "FP_COST = 0.1 # cost for a false‑positive slot\n", + "EPS = 1e-6\n", + "# ────────────────────────────────────────────────────────────────\n", + "\n", + "# Pre‑compute all slot permutations (K! rows, each of length K)\n", + "_PERMS = tf.constant(list(permutations(range(K))), tf.int32) # (P, K)\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def permuted_rf_loss(y_true, y_pred):\n", + " \"\"\"\n", + " y_true, y_pred : (B, H, W, K, 3) — slots = [p, x̄, ȳ]\n", + " • y_pred[...,0] is already sigmoid‑gated (0‑1 probability)\n", + " • x̄, ȳ are in [0,1] normalised RF coordinates\n", + " Returns scalar mean loss over all (B·H·W) receptive‑field cells.\n", + " \"\"\"\n", + "\n", + " # ── 1) flatten spatial dims so each RF cell is a sample ──\n", + " B, H, W = tf.shape(y_pred)[0], tf.shape(y_pred)[1], tf.shape(y_pred)[2]\n", + " N = B * H * W # total cells\n", + " y_t = tf.reshape(y_true, (N, K, 3)) # (N,K,3)\n", + " y_p = tf.reshape(y_pred, (N, K, 3)) # (N,K,3)\n", + "\n", + " # ── 2) split components ────────────────────────────────\n", + " p_t, xy_t = y_t[..., 0], y_t[..., 1:3] # (N,K) , (N,K,2)\n", + " p_p, xy_p = y_p[..., 0], y_p[..., 1:3] # (N,K) , (N,K,2)\n", + "\n", + " # ── 3) gather every slot permutation (along axis‑1) ────\n", + " p_p_perm = tf.gather(p_p, _PERMS, axis=1) # (N,P,K)\n", + " xy_p_perm = tf.gather(xy_p, _PERMS, axis=1) # (N,P,K,2)\n", + "\n", + " # broadcast GT for per‑perm comparison\n", + " p_t_b = tf.expand_dims(p_t, 1) # (N,1,K)\n", + " xy_t_b = tf.expand_dims(xy_t,1) # (N,1,K,2)\n", + "\n", + "\n", + " bce = -( POS_W * p_t_b * tf.math.log(p_p_perm + EPS)\n", + " + (1.0 - p_t_b) * tf.math.log(1.0 - p_p_perm + EPS) ) # (N,P,K)\n", + " loss_p = tf.reduce_sum(bce, axis=2) # (N,P)\n", + "\n", + " # ─────────────────────────────────────────────────────────\n", + " # 5) Coordinate loss – MSE *only* on GT‑positive slots\n", + " mask_pos = tf.cast(p_t_b > 0.5, tf.float32) # (N,1,K)\n", + " se = tf.reduce_sum(tf.square(xy_t_b - xy_p_perm), axis=-1) # (N,P,K)\n", + " se_masked = se * mask_pos\n", + " denom = tf.reduce_sum(mask_pos, axis=2) + EPS # (N,1)\n", + " loss_xy = tf.reduce_sum(se_masked, axis=2) / denom # (N,P)\n", + "\n", + " # ─────────────────────────────────────────────────────────\n", + " # 6) False‑positive slot penalty (encourages p→0 on empty slots)\n", + " mask_neg = 1.0 - mask_pos # (N,1,K)\n", + " loss_fp = FP_COST * tf.reduce_sum(mask_neg * p_p_perm, axis=2) # (N,P)\n", + "\n", + " # ── 7) combine losses & take best permutation ────────────\n", + " cost = loss_p + LAMBDA_XY*loss_xy + loss_fp # (N,P)\n", + " best = tf.reduce_min(cost, axis=1) # (N,)\n", + " return tf.reduce_mean(best) # scalar\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "f70d3a33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"RF8_Detector\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"RF8_Detector\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_2 (InputLayer)      │ (None, 256, 256, 1)    │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_8 (Conv2D)               │ (None, 256, 256, 128)  │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_9 (Conv2D)               │ (None, 256, 256, 128)  │       147,584 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_10 (Conv2D)              │ (None, 256, 256, 128)  │       147,584 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_2 (MaxPooling2D)  │ (None, 128, 128, 128)  │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_11 (Conv2D)              │ (None, 128, 128, 12)   │         1,548 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape_2 (Reshape)             │ (None, 128, 128, 4, 3) │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ lambda_2 (Lambda)               │ (None, 128, 128, 4, 3) │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_2 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m, \u001b[38;5;34m256\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_8 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m, \u001b[38;5;34m256\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_9 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m, \u001b[38;5;34m256\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m147,584\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_10 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m, \u001b[38;5;34m256\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m147,584\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_11 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m12\u001b[0m) │ \u001b[38;5;34m1,548\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape_2 (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ lambda_2 (\u001b[38;5;33mLambda\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 297,996 (1.14 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m297,996\u001b[0m (1.14 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 297,996 (1.14 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m297,996\u001b[0m (1.14 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tensorflow.keras.optimizers import Adam\n", + "\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=5, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " model = create_rf8_detector()\n", + " model.compile(optimizer=Adam(learning_rate = 0.001), loss = permuted_rf_loss)\n", + " model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "8c74c95b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:19:47.826909: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 773ms/step - loss: 1.1218" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:20:49.992900: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 829ms/step - loss: 1.1127 - val_loss: 0.0530\n", + "Epoch 2/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 779ms/step - loss: 0.0450" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:21:52.355690: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 811ms/step - loss: 0.0449 - val_loss: 0.0162\n", + "Epoch 3/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 777ms/step - loss: 0.0145" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:22:55.302638: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 826ms/step - loss: 0.0145 - val_loss: 0.0129\n", + "Epoch 4/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 777ms/step - loss: 0.0126" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:23:57.394023: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 813ms/step - loss: 0.0125 - val_loss: 0.0122\n", + "Epoch 5/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 779ms/step - loss: 0.0120" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:25:00.225461: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 824ms/step - loss: 0.0120 - val_loss: 0.0118\n", + "Epoch 6/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 777ms/step - loss: 0.0117" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:26:02.639208: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 816ms/step - loss: 0.0117 - val_loss: 0.0116\n", + "Epoch 7/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 782ms/step - loss: 0.0115" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:27:05.071020: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 819ms/step - loss: 0.0115 - val_loss: 0.0115\n", + "Epoch 8/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 777ms/step - loss: 0.0113" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:28:08.038588: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 823ms/step - loss: 0.0113 - val_loss: 0.0114\n", + "Epoch 9/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 781ms/step - loss: 0.0113" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:29:10.160449: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 815ms/step - loss: 0.0113 - val_loss: 0.0113\n", + "Epoch 10/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 777ms/step - loss: 0.0113" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:30:13.485227: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 818ms/step - loss: 0.0113 - val_loss: 0.0113\n", + "Epoch 11/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 778ms/step - loss: 0.0112" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:31:16.853973: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 831ms/step - loss: 0.0112 - val_loss: 0.0112\n", + "Epoch 12/12\n", + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 782ms/step - loss: 0.0111" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 17:32:19.343162: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m75/75\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 816ms/step - loss: 0.0111 - val_loss: 0.0112\n" + ] + } + ], + "source": [ + "history = model.fit(\n", + " train_ds,\n", + " validation_data=val_ds,\n", + " epochs=12\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "a1e187b4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "plot_training_history(history)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "f31d4a03", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_706921/1351926076.py:26: UserWarning: You passed both c and facecolor/facecolors for the markers. c has precedence over facecolor/facecolors. This behavior may change in the future.\n", + " plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "idx = np.random.randint(len(X_images))\n", + "# idx =6869\n", + "img = X_images[idx,...,0]\n", + "gt_lbl = y_labels[idx]\n", + "pred_lbl = model.predict(img[None],verbose=0)[0]\n", + "\n", + "# reuse the scatter logic from before\n", + "def unpack(lbl_tensor, threshold=0.5):\n", + " \n", + " r,c,k = np.where(lbl_tensor[...,0] > threshold)\n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + " x = x0 + lbl_tensor[r,c,k,1]*RF_SIZE\n", + " y = y0 + lbl_tensor[r,c,k,2]*RF_SIZE\n", + " return x, y\n", + "\n", + "x_gt, y_gt = unpack(gt_lbl, threshold=0.5)\n", + "x_pr, y_pr = unpack(pred_lbl, threshold=0.5)\n", + "\n", + "plt.figure(figsize=(12,12))\n", + "plt.imshow(img,cmap='gray', origin=\"upper\")\n", + "plt.scatter(x_gt, y_gt, c=\"red\", marker=\"x\", s=40, label=\"GT\")\n", + "plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "plt.title(f\"Frame {idx}\")\n", + "plt.legend(loc=\"lower right\")\n", + "# plt.xlim(0,63); plt.ylim(63,0); plt.show()\n", + "plt.xlim(0,255); plt.ylim(255,0); plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "c490d00d", + "metadata": {}, + "outputs": [], + "source": [ + "# plt.figure(figsize=(12,12))\n", + "# plt.imshow(img,cmap='gray', origin=\"upper\")\n", + "# plt.scatter(, y_gt, c=\"red\", marker=\"x\", s=40, label=\"GT\")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "fe87c736", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GT# 0 @ cell ( 2, 15) — best slot 3 has p=0.000\n", + "GT# 1 @ cell ( 3, 20) — best slot 3 has p=0.000\n", + "GT# 2 @ cell ( 3, 45) — best slot 3 has p=0.000\n", + "GT# 3 @ cell ( 3,103) — best slot 3 has p=0.000\n", + "GT# 4 @ cell ( 4, 87) — best slot 3 has p=0.000\n", + "GT# 5 @ cell ( 6, 61) — best slot 3 has p=0.000\n", + "GT# 6 @ cell ( 6,102) — best slot 3 has p=0.000\n", + "GT# 7 @ cell ( 7, 9) — best slot 3 has p=0.000\n", + "GT# 8 @ cell ( 7, 90) — best slot 3 has p=0.976\n", + "GT# 9 @ cell ( 10, 78) — best slot 3 has p=0.000\n", + "GT#10 @ cell ( 10, 95) — best slot 3 has p=0.000\n", + "GT#11 @ cell ( 11, 65) — best slot 3 has p=0.000\n", + "GT#12 @ cell ( 13, 30) — best slot 3 has p=0.000\n", + "GT#13 @ cell ( 14,102) — best slot 3 has p=0.000\n", + "GT#14 @ cell ( 18, 57) — best slot 3 has p=0.000\n", + "GT#15 @ cell ( 20, 59) — best slot 3 has p=0.000\n", + "GT#16 @ cell ( 21, 7) — best slot 3 has p=0.000\n", + "GT#17 @ cell ( 21, 77) — best slot 3 has p=0.000\n", + "GT#18 @ cell ( 21, 83) — best slot 3 has p=0.000\n", + "GT#19 @ cell ( 22, 3) — best slot 3 has p=0.000\n", + "GT#20 @ cell ( 23, 84) — best slot 3 has p=0.098\n", + "GT#21 @ cell ( 25, 73) — best slot 3 has p=0.000\n", + "GT#22 @ cell ( 26, 89) — best slot 3 has p=0.000\n", + "GT#23 @ cell ( 28, 42) — best slot 3 has p=0.000\n", + "GT#24 @ cell ( 28,120) — best slot 3 has p=0.000\n", + "GT#25 @ cell ( 29, 8) — best slot 3 has p=0.001\n", + "GT#26 @ cell ( 30, 30) — best slot 3 has p=0.000\n", + "GT#27 @ cell ( 30, 55) — best slot 3 has p=0.000\n", + "GT#28 @ cell ( 31, 61) — best slot 3 has p=0.000\n", + "GT#29 @ cell ( 31, 77) — best slot 3 has p=0.000\n", + "GT#30 @ cell ( 35,115) — best slot 3 has p=0.000\n", + "GT#31 @ cell ( 36, 34) — best slot 3 has p=0.000\n", + "GT#32 @ cell ( 37,101) — best slot 3 has p=0.000\n", + "GT#33 @ cell ( 38, 37) — best slot 3 has p=0.000\n", + "GT#34 @ cell ( 40, 23) — best slot 3 has p=0.000\n", + "GT#35 @ cell ( 40, 95) — best slot 3 has p=0.000\n", + "GT#36 @ cell ( 41, 32) — best slot 3 has p=0.000\n", + "GT#37 @ cell ( 43, 46) — best slot 3 has p=0.000\n", + "GT#38 @ cell ( 43, 79) — best slot 3 has p=0.000\n", + "GT#39 @ cell ( 44, 15) — best slot 3 has p=0.000\n", + "GT#40 @ cell ( 44, 94) — best slot 3 has p=0.000\n", + "GT#41 @ cell ( 49, 56) — best slot 3 has p=0.000\n", + "GT#42 @ cell ( 49, 79) — best slot 3 has p=0.000\n", + "GT#43 @ cell ( 50, 60) — best slot 3 has p=0.000\n", + "GT#44 @ cell ( 52, 39) — best slot 3 has p=0.000\n", + "GT#45 @ cell ( 52, 82) — best slot 3 has p=0.000\n", + "GT#46 @ cell ( 52,102) — best slot 3 has p=0.000\n", + "GT#47 @ cell ( 54, 80) — best slot 3 has p=0.000\n", + "GT#48 @ cell ( 57,106) — best slot 3 has p=0.000\n", + "GT#49 @ cell ( 58, 34) — best slot 3 has p=0.000\n", + "GT#50 @ cell ( 58,115) — best slot 3 has p=0.000\n", + "GT#51 @ cell ( 60,126) — best slot 3 has p=0.000\n", + "GT#52 @ cell ( 61, 22) — best slot 3 has p=0.000\n", + "GT#53 @ cell ( 63,116) — best slot 3 has p=0.000\n", + "GT#54 @ cell ( 68, 32) — best slot 3 has p=0.000\n", + "GT#55 @ cell ( 68, 95) — best slot 3 has p=0.000\n", + "GT#56 @ cell ( 72, 69) — best slot 3 has p=0.000\n", + "GT#57 @ cell ( 72,111) — best slot 3 has p=0.000\n", + "GT#58 @ cell ( 75, 46) — best slot 3 has p=0.000\n", + "GT#59 @ cell ( 75, 63) — best slot 3 has p=0.000\n", + "GT#60 @ cell ( 78, 91) — best slot 3 has p=0.000\n", + "GT#61 @ cell ( 78,102) — best slot 3 has p=0.000\n", + "GT#62 @ cell ( 79, 45) — best slot 3 has p=0.000\n", + "GT#63 @ cell ( 80, 30) — best slot 3 has p=0.000\n", + "GT#64 @ cell ( 81, 96) — best slot 3 has p=0.000\n", + "GT#65 @ cell ( 86, 3) — best slot 3 has p=0.000\n", + "GT#66 @ cell ( 86, 48) — best slot 3 has p=0.000\n", + "GT#67 @ cell ( 88, 56) — best slot 3 has p=0.115\n", + "GT#68 @ cell ( 90, 65) — best slot 3 has p=0.000\n", + "GT#69 @ cell ( 91, 52) — best slot 3 has p=0.000\n", + "GT#70 @ cell ( 91, 64) — best slot 3 has p=0.000\n", + "GT#71 @ cell ( 91, 96) — best slot 3 has p=0.000\n", + "GT#72 @ cell ( 92, 55) — best slot 3 has p=0.000\n", + "GT#73 @ cell ( 93, 20) — best slot 3 has p=0.000\n", + "GT#74 @ cell ( 93, 33) — best slot 3 has p=0.000\n", + "GT#75 @ cell ( 97, 64) — best slot 3 has p=0.000\n", + "GT#76 @ cell ( 98, 9) — best slot 3 has p=0.074\n", + "GT#77 @ cell (104, 82) — best slot 3 has p=0.000\n", + "GT#78 @ cell (107, 52) — best slot 3 has p=0.000\n", + "GT#79 @ cell (108, 13) — best slot 3 has p=0.000\n", + "GT#80 @ cell (108, 41) — best slot 3 has p=0.000\n", + "GT#81 @ cell (108, 74) — best slot 3 has p=0.000\n", + "GT#82 @ cell (108,114) — best slot 3 has p=0.000\n", + "GT#83 @ cell (109, 65) — best slot 3 has p=0.000\n", + "GT#84 @ cell (109,124) — best slot 3 has p=0.948\n", + "GT#85 @ cell (110, 61) — best slot 3 has p=0.000\n", + "GT#86 @ cell (111, 57) — best slot 3 has p=0.000\n", + "GT#87 @ cell (112,127) — best slot 3 has p=0.000\n", + "GT#88 @ cell (116,100) — best slot 3 has p=0.000\n", + "GT#89 @ cell (117, 92) — best slot 3 has p=0.000\n", + "GT#90 @ cell (118, 40) — best slot 3 has p=0.000\n", + "GT#91 @ cell (119,100) — best slot 3 has p=0.004\n", + "GT#92 @ cell (120, 27) — best slot 3 has p=0.000\n", + "GT#93 @ cell (120,110) — best slot 3 has p=0.000\n", + "GT#94 @ cell (121, 6) — best slot 3 has p=0.621\n", + "GT#95 @ cell (122, 44) — best slot 3 has p=0.000\n", + "GT#96 @ cell (124, 10) — best slot 3 has p=0.000\n", + "GT#97 @ cell (124, 80) — best slot 3 has p=0.000\n", + "GT#98 @ cell (125, 43) — best slot 3 has p=0.000\n", + "GT#99 @ cell (127,127) — best slot 3 has p=0.000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-03 16:35:31.564592: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# pick your sample\n", + "# idx = 6869\n", + "gt_lbl = y_labels[idx] # (128,128,K,3)\n", + "pred_lbl = model.predict(img[None],verbose=0)[0]\n", + "\n", + "# get all GT slots (r,c,k) where p_true=1\n", + "r_gt, c_gt, k_gt = np.where(gt_lbl[...,0] > 0.5)\n", + "\n", + "# grab the model’s presence‐probs at each (r,c)\n", + "p_pred = pred_lbl[...,0] # shape (128,128,K)\n", + "\n", + "for i,(r,c) in enumerate(zip(r_gt,c_gt)):\n", + " slot_probs = p_pred[r,c,:]\n", + " best_j = np.argmax(slot_probs)\n", + " best_p = slot_probs[best_j]\n", + " print(f\"GT#{i:2d} @ cell ({r:3d},{c:3d}) — best slot {best_j} has p={best_p:.3f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "fb6a35b4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_637188/2497575874.py:15: UserWarning: You passed both c and facecolor/facecolors for the markers. c has precedence over facecolor/facecolors. This behavior may change in the future.\n", + " plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "/tmp/ipykernel_637188/2497575874.py:17: UserWarning: You passed both c and facecolor/facecolors for the markers. c has precedence over facecolor/facecolors. This behavior may change in the future.\n", + " plt.scatter(x_low, y_low, c=\"yellow\", marker=\"o\", s=100, facecolors=\"none\",\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# define masks\n", + "low_mask = [i for i,(r,c) in enumerate(zip(r_gt,c_gt))\n", + " if p_pred[r,c,:].max() < 0.5]\n", + "x_low = [(c_gt[i]*STRIDE - OFFSET) + gt_lbl[r_gt[i],c_gt[i],k_gt[i],1]*RF_SIZE \n", + " for i in low_mask]\n", + "y_low = [(r_gt[i]*STRIDE - OFFSET) + gt_lbl[r_gt[i],c_gt[i],k_gt[i],2]*RF_SIZE \n", + " for i in low_mask]\n", + "\n", + "# your existing plot\n", + "plt.figure(figsize=(12,12))\n", + "plt.imshow(img, cmap=\"gray\", origin=\"upper\")\n", + "plt.scatter(x_gt, y_gt, c=\"red\", marker=\"x\", s=40, label=\"all GT\")\n", + "plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "# highlight the ones below threshold\n", + "plt.scatter(x_low, y_low, c=\"yellow\", marker=\"o\", s=100, facecolors=\"none\", \n", + " label=\"p<0.5 GT\")\n", + "plt.legend(loc=\"lower right\")\n", + "plt.title(f\"Frame {idx}\")\n", + "plt.xlim(0, IMAGE_SIZE); plt.ylim(IMAGE_SIZE, 0)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "6badeb76", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# grab all best‐slot probs at each GT cell\n", + "probs = []\n", + "for (r,c) in zip(r_gt, c_gt):\n", + " probs.append(p_pred[r,c,:].max())\n", + "\n", + "plt.figure(figsize=(6,5))\n", + "plt.hist(probs, bins=30, range=(0,1))\n", + "plt.axvline(0.5, color=\"red\", linestyle=\"--\", label=\"current threshold\")\n", + "plt.xlabel(\"max p_pred at GT cells\")\n", + "plt.ylabel(\"count\")\n", + "plt.legend()\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ObjectDetection2", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ComputerVision_OD_Electron_Counting/Receptive_Field_noProb.ipynb b/ComputerVision_OD_Electron_Counting/Receptive_Field_noProb.ipynb new file mode 100644 index 0000000..e32e89c --- /dev/null +++ b/ComputerVision_OD_Electron_Counting/Receptive_Field_noProb.ipynb @@ -0,0 +1,5770 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6b5a6fcd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 14:43:44.364251: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-05-20 14:43:44.378893: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1747766624.392328 1632990 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1747766624.396382 1632990 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1747766624.409222 1632990 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747766624.409240 1632990 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747766624.409242 1632990 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747766624.409244 1632990 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2025-05-20 14:43:44.413073: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:2',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I0000 00:00:1747766626.719166 1632990 gpu_device.cc:2019] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 77751 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\" # Only GPUs 6 and 7 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:2\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "534e7c3e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "05c9821e", + "metadata": {}, + "outputs": [], + "source": [ + "import h5py, numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ─── geometry constants ─────────────────────────────────────────\n", + "IMAGE_SIZE = 256\n", + "GRID = 128\n", + "STRIDE = 2\n", + "RF_SIZE = 8\n", + "OFFSET = RF_SIZE // 2 # 4\n", + "MAX_HITS = 2\n", + "# ────────────────────────────────────────────────────────────────\n", + "\n", + "def build_label(hit_array: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " hit_array: (M,3) rows = [id, x_px, y_px] in 64×64 coords\n", + " returns : (32,32,MAX_HITS,3) with slots [p, nx, ny]\n", + " \"\"\"\n", + " lbl = np.zeros((GRID, GRID, MAX_HITS, 3), dtype=np.float32)\n", + " slot_idx = np.zeros((GRID, GRID), dtype=np.int8)\n", + "\n", + " for _i, x_px, y_px in hit_array:\n", + " # 1) which output cell\n", + " c = int(x_px // STRIDE)\n", + " r = int(y_px // STRIDE)\n", + " if not (0 <= r < GRID and 0 <= c < GRID):\n", + " continue\n", + "\n", + " k = slot_idx[r, c]\n", + " if k >= MAX_HITS:\n", + " continue\n", + "\n", + " # 2) top‐left of this RF in input space\n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + "\n", + " # 3) local normalised coords\n", + " nx = (x_px - x0) / RF_SIZE\n", + " ny = (y_px - y0) / RF_SIZE\n", + " # nx = np.clip(nx, 0.0, 1)\n", + " # ny = np.clip(ny, 0.0, 1)\n", + "\n", + " # 4) write slot\n", + " lbl[r, c, k, 0] = 1.0\n", + " lbl[r, c, k, 1] = nx\n", + " lbl[r, c, k, 2] = ny\n", + " slot_idx[r, c] += 1\n", + "\n", + " return lbl\n", + "\n", + "\n", + "def load_dataset(h5_path: str, max_samples: int = None):\n", + " \"\"\"Returns X:(N,64,64,1), y:(N,32,32,MAX_HITS,3)\"\"\"\n", + " with h5py.File(h5_path, \"r\") as f:\n", + " imgs = np.asarray(f[\"images\"][:max_samples], np.float32)\n", + " centers = np.asarray(f[\"centers_training\"][:max_samples]) # (N,M,3)\n", + "\n", + " # normalize + add channel\n", + " X = imgs / (imgs.max() + 1e-7)\n", + " X = X[..., None] # (N,64,64,1)\n", + "\n", + " # build per‐frame label\n", + " y = np.stack([build_label(hits) for hits in centers], axis=0)\n", + " # y.shape == (N,32,32,MAX_HITS,3)\n", + "\n", + " return X, y\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c4d5037e", + "metadata": {}, + "outputs": [], + "source": [ + "h5_file = \"/home/da886/ComputerVision_OD_Electron_Counting/Images_and_Labels/50KFixed_100_256by256_RandomindexNoNoise.h5\"\n", + "X_images,y_labels = load_dataset(h5_file, max_samples=10000) " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c0c76472", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: (9500, 256, 256, 1) (9500, 128, 128, 2, 3)\n", + " Val : (500, 256, 256, 1) (500, 128, 128, 2, 3)\n" + ] + } + ], + "source": [ + "X_train, X_val, y_train, y_val = train_test_split(\n", + " X_images, y_labels,\n", + " test_size=0.05,\n", + " random_state=42,\n", + " shuffle=True\n", + ")\n", + "\n", + "print(\"Train:\", X_train.shape, y_train.shape)\n", + "print(\" Val :\", X_val.shape, y_val.shape)\n", + "\n", + "# 3) Build tf.data pipelines\n", + "batch_size = 64\n", + "\n", + "train_ds = (\n", + " tf.data.Dataset\n", + " .from_tensor_slices((X_train, y_train))\n", + " .shuffle(buffer_size=len(X_train), seed=42)\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE)\n", + ")\n", + "\n", + "val_ds = (\n", + " tf.data.Dataset\n", + " .from_tensor_slices((X_val, y_val))\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "794b6532", + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "# from tensorflow.keras import layers, Model\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def gating_spatial(tensor):\n", + "# raw_p = tensor[..., 0] \n", + "# xy = tensor[..., 1:3] \n", + "# p = tf.sigmoid(raw_p)[..., None] \n", + "# gate = tf.cast(p > 0.5, tf.float32)\n", + "# xy_g = xy * gate\n", + " \n", + "# return tf.concat([p, xy_g], axis=-1) \n", + "\n", + "# def create_rf8_detector(input_shape=(256,256,1), max_hits=2):\n", + "# inp = layers.Input(shape=input_shape)\n", + "\n", + " \n", + "# x = layers.Conv2D(32, 3, padding='same', activation='relu')(inp)\n", + "# x = layers.MaxPooling2D(2,padding = 'same')(x) \n", + "# x = layers.Conv2D(16, 3, padding='same', activation='relu')(x) \n", + "# # x = layers.Conv2D(64, 3, padding='same', activation='relu')(x)\n", + " \n", + "\n", + " \n", + "# x = layers.Conv2D(max_hits*3, 1, padding='same')(x)\n", + "# x = layers.Reshape((128,128,max_hits,3))(x)\n", + "# out = layers.Lambda(gating_spatial)(x)\n", + " \n", + " \n", + "# return Model(inp, out, name=\"RF8_Detector\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "5589aecd", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "from itertools import permutations\n", + "import numpy as np\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def gating_spatial(tensor):\n", + " raw_p = tensor[..., 0]\n", + " xy = tensor[..., 1:3]\n", + " p = tf.sigmoid(raw_p)[..., None]\n", + " gate = tf.cast(p > 0.5, tf.float32)\n", + " xy_g = xy * gate\n", + " return tf.concat([p, xy_g], axis=-1)\n", + "\n", + "eps = 1e-6\n", + " \n", + "class RF8Detector(tf.keras.Model):\n", + " def __init__(self, input_shape=(256,256,1), max_hits=2):\n", + " super().__init__()\n", + " self.max_hits = max_hits\n", + " self.perms = tf.constant(list(permutations(range(max_hits))), dtype=tf.int32)\n", + " # Weighting factors for different hit counts\n", + " self.hit_weights = {1: 3.0, 2: 2.0} # Higher weight for 1-hit cells\n", + " \n", + " \n", + " \n", + " self.conv_block = tf.keras.Sequential([\n", + " layers.Conv2D(32, 3, padding='same', activation='relu', input_shape=input_shape),\n", + " layers.MaxPooling2D(2, padding='same'),\n", + " layers.Conv2D(16, 3, padding='same', activation='relu')\n", + " ])\n", + " self.output_block = tf.keras.Sequential([\n", + " layers.Conv2D(max_hits*3, 1, padding='same'),\n", + " layers.Reshape((128,128,max_hits,3)),\n", + " layers.Lambda(gating_spatial)\n", + " ])\n", + " self.build(input_shape=(None,) + input_shape)\n", + " \n", + " def call(self, inputs):\n", + " x = self.conv_block(inputs)\n", + " return self.output_block(x)\n", + " \n", + " # def compute_permuted_loss(self, y_true, y_pred):\n", + " # p_true = y_true[..., 0] # (B,H,W,K)\n", + " # xy_true = y_true[..., 1:] # (B,H,W,K,2)\n", + " # p_pred = y_pred[..., 0] # (B,H,W,K)\n", + " # xy_pred = y_pred[..., 1:] # (B,H,W,K,2)\n", + " \n", + " # B, H, W, K = tf.unstack(tf.shape(p_true))\n", + " # N = B * H * W\n", + " \n", + " # # Reshape tensors\n", + " # p_t = tf.reshape(p_true, [N, K])\n", + " # xy_t = tf.reshape(xy_true, [N, K, 2])\n", + " # p_p = tf.reshape(p_pred, [N, K])\n", + " # xy_p = tf.reshape(xy_pred, [N, K, 2])\n", + " \n", + " # # 1. BCE in natural order with hit-count weighting\n", + " # bce = tf.keras.losses.binary_crossentropy(p_t, p_p) # (N,)\n", + " \n", + " # # 2. Find best permutation for MSE only\n", + " # xy_p_perm = tf.gather(xy_p, self.perms, axis=1) # (N,P,K,2)\n", + " # mask = tf.cast(p_t > 0.5, tf.float32)[:, tf.newaxis, :] # (N,1,K)\n", + " # se = tf.reduce_sum(tf.square(xy_t[:, tf.newaxis] - xy_p_perm), axis=-1) # (N,P,K)\n", + " # mse_per_perm = tf.reduce_sum(se * mask, axis=2) / (tf.reduce_sum(mask, axis=2) + eps) # (N,P)\n", + " # best_perm_idx = tf.argmin(mse_per_perm, axis=1) # (N,)\n", + " # best_mse = tf.gather(mse_per_perm, best_perm_idx, batch_dims=1) # (N,)\n", + " \n", + " # # 3. Apply hit-count weighting\n", + " # num_hits = tf.reduce_sum(tf.cast(p_t > 0.5, tf.int32), axis=1) # (N,)\n", + " # weights = tf.where(\n", + " # num_hits == 1, self.hit_weights[1],\n", + " # tf.where(num_hits == 2, self.hit_weights[2], 1.0)\n", + " # )\n", + " \n", + " # # 4. Compute weighted losses\n", + " # weighted_bce = bce * weights\n", + " # weighted_mse = best_mse * weights\n", + " \n", + " # return (\n", + " # tf.reduce_mean(weighted_bce) + tf.reduce_mean(weighted_mse),\n", + " # tf.reduce_mean(weighted_bce),\n", + " # tf.reduce_mean(weighted_mse)\n", + " # )\n", + " def compute_permuted_loss(self, y_true, y_pred):\n", + " # ─── unpack tensors ───────────────────────────────────────────\n", + " p_true, xy_true = y_true[..., 0], y_true[..., 1:] # (B,H,W,K) , (B,H,W,K,2)\n", + " p_pred, xy_pred = y_pred[..., 0], y_pred[..., 1:]\n", + "\n", + " B, H, W, K = tf.unstack(tf.shape(p_true))\n", + " N = B * H * W\n", + "\n", + " # ─── flatten spatial dims ─────────────────────────────────────\n", + " p_t = tf.reshape(p_true, [N, K]) # (N,K)\n", + " xy_t = tf.reshape(xy_true, [N, K, 2]) # (N,K,2)\n", + " p_p = tf.reshape(p_pred, [N, K])\n", + " xy_p = tf.reshape(xy_pred, [N, K, 2])\n", + "\n", + " # ─── 1) BCE (natural order) ──────────────────────────────────\n", + " bce = tf.keras.losses.binary_crossentropy(p_t, p_p) # (N,)\n", + "\n", + " # ─── 2) permutation-optimised MSE ───────────────────────────\n", + " xy_p_perm = tf.gather(xy_p, self.perms, axis=1) # (N,P,K,2)\n", + " mask = tf.cast(p_t > 0.5, tf.float32)[:, None] # (N,1,K)\n", + " se = tf.reduce_sum(tf.square(xy_t[:, None] - xy_p_perm), axis=-1) # (N,P,K)\n", + " mse_per_perm = tf.reduce_sum(se * mask, axis=2) / (tf.reduce_sum(mask, axis=2) + eps) # (N,P)\n", + " best_perm_idx = tf.argmin(mse_per_perm, axis=1) # (N,)\n", + " best_mse = tf.gather(mse_per_perm, best_perm_idx, batch_dims=1) # (N,)\n", + "\n", + " # ─── 3) hit-count weighting ─────────────────────────────────\n", + " num_hits = tf.reduce_sum(tf.cast(p_t > 0.5, tf.int32), axis=1) # (N,)\n", + " weights = tf.where(num_hits == 1, self.hit_weights[1],\n", + " tf.where(num_hits == 2, self.hit_weights[2], 1.0))\n", + "\n", + " weighted_bce = bce * weights # (N,)\n", + " weighted_mse = best_mse * weights # (N,)\n", + "\n", + " # ─── 4) *separate* means ────────────────────────────────────\n", + " mean_bce = tf.reduce_sum(weighted_bce) / tf.reduce_sum(weights) # all cells\n", + " active = tf.cast(num_hits > 0, tf.float32) # (N,)\n", + " mean_mse = (tf.reduce_sum(weighted_mse * active) /\n", + " tf.reduce_sum(weights * active) ) # only hit cells\n", + "\n", + " total_loss = mean_bce + mean_mse\n", + " return total_loss, mean_bce, mean_mse\n", + "\n", + " @tf.function\n", + " def train_step(self, data):\n", + " x, y_true = data\n", + " with tf.GradientTape() as tape:\n", + " y_pred = self(x, training=True)\n", + " total_loss, bce, mse = self.compute_permuted_loss(y_true, y_pred)\n", + " grads = tape.gradient(total_loss, self.trainable_variables)\n", + " self.optimizer.apply_gradients(zip(grads, self.trainable_variables))\n", + " return {'loss': total_loss, 'bce': bce, 'mse': mse}\n", + " \n", + " @tf.function\n", + " def test_step(self, data):\n", + " x, y_true = data\n", + " y_pred = self(x, training=False)\n", + " total_loss, bce, mse = self.compute_permuted_loss(y_true, y_pred)\n", + " return {'val_loss': total_loss, 'val_bce': bce, 'val_mse': mse}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0838934", + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def masked_bce_mse_loss(y_true, y_pred):\n", + "# \"\"\"\n", + "# Combined loss with:\n", + "# - BCE for slot probabilities (p)\n", + "# - Masked MSE for coordinates (xy) where p_true > 0\n", + " \n", + "# Args:\n", + "# y_true: Ground truth [p, x, y] with shape (..., K, 3)\n", + "# y_pred: Predictions [p, x, y] with shape (..., K, 3)\n", + "# Returns:\n", + "# Total loss = BCE + MSE (scalar)\n", + "# \"\"\"\n", + "# # Split components\n", + "# p_true = y_true[..., 0] # (..., K)\n", + "# xy_true = y_true[..., 1:] # (..., K, 2)\n", + "# p_pred = y_pred[..., 0] # (..., K) (must be sigmoid-activated)\n", + "# xy_pred = y_pred[..., 1:] # (..., K, 2)\n", + "\n", + "# # ===== 1. BCE Calculation =====\n", + "# bce = tf.keras.losses.binary_crossentropy(p_true, p_pred) # (..., K)\n", + "# bce = tf.reduce_mean(bce) # Scalar\n", + "\n", + "# # ===== 2. Masked MSE Calculation =====\n", + "# mask = tf.cast(p_true > 0, tf.float32) # (..., K)\n", + "# mask = tf.expand_dims(mask, axis=-1) # (..., K, 1) for broadcasting\n", + "# squared_error = tf.square(xy_true - xy_pred) # (..., K, 2)\n", + "# masked_se = squared_error * mask # Zero out inactive slots\n", + " \n", + "# # Normalize by active slots (avoid div-by-zero)\n", + "# active_slots = tf.reduce_sum(mask) + tf.keras.backend.epsilon()\n", + "# mse = tf.reduce_sum(masked_se) / active_slots # Scalar\n", + "\n", + "# # ===== 3. Combine Losses =====\n", + "# total_loss = bce + mse\n", + " \n", + "# # Optional: Track components separately\n", + "# tf.summary.scalar('bce', bce)\n", + "# tf.summary.scalar('mse', mse)\n", + " \n", + "# return total_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "f70d3a33", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/da886/anaconda3/envs/ObjectDetection2/lib/python3.11/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n", + "/home/da886/anaconda3/envs/ObjectDetection2/lib/python3.11/site-packages/keras/src/layers/layer.py:396: UserWarning: `build()` was called on layer 'rf8_detector_2', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"rf8_detector_2\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"rf8_detector_2\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ sequential_4 (Sequential)       │ (None, 128, 128, 16)   │         4,944 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ sequential_5 (Sequential)       │ ?                      │   0 (unbuilt) │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ sequential_4 (\u001b[38;5;33mSequential\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m4,944\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ sequential_5 (\u001b[38;5;33mSequential\u001b[0m) │ ? │ \u001b[38;5;34m0\u001b[0m (unbuilt) │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 4,944 (19.31 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m4,944\u001b[0m (19.31 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 4,944 (19.31 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m4,944\u001b[0m (19.31 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tensorflow.keras.optimizers import Adam\n", + "\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=5, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " model = RF8Detector(input_shape=(256,256,1), max_hits=2)\n", + " model.compile(optimizer=Adam(learning_rate = 0.0001))\n", + " model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "8c74c95b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:01:47.668901: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 71ms/step - bce: 0.6785 - loss: 1.2548 - mse: 0.5763 - val_val_bce: 0.6518 - val_val_loss: 1.2885 - val_val_mse: 0.6367\n", + "Epoch 2/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 51ms/step - bce: 0.5956 - loss: 1.2368 - mse: 0.6411 - val_val_bce: 0.5188 - val_val_loss: 1.1605 - val_val_mse: 0.6417\n", + "Epoch 3/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 38ms/step - bce: 0.4114 - loss: 1.0528 - mse: 0.6413" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:02:16.224792: I tensorflow/core/framework/local_rendezvous.cc:407] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 52ms/step - bce: 0.4107 - loss: 1.0520 - mse: 0.6413 - val_val_bce: 0.3021 - val_val_loss: 0.9438 - val_val_mse: 0.6417\n", + "Epoch 4/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 39ms/step - bce: 0.2201 - loss: 0.8615 - mse: 0.6413" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:02:24.111680: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 50ms/step - bce: 0.2193 - loss: 0.8606 - mse: 0.6413 - val_val_bce: 0.1540 - val_val_loss: 0.7957 - val_val_mse: 0.6417\n", + "Epoch 5/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 57ms/step - bce: 0.1192 - loss: 0.7606 - mse: 0.6413 - val_val_bce: 0.0943 - val_val_loss: 0.7360 - val_val_mse: 0.6417\n", + "Epoch 6/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 53ms/step - bce: 0.0816 - loss: 0.7229 - mse: 0.6413 - val_val_bce: 0.0721 - val_val_loss: 0.7137 - val_val_mse: 0.6417\n", + "Epoch 7/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 47ms/step - bce: 0.0666 - loss: 0.7079 - mse: 0.6414 - val_val_bce: 0.0622 - val_val_loss: 0.7039 - val_val_mse: 0.6417\n", + "Epoch 8/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 31ms/step - bce: 0.0596 - loss: 0.7009 - mse: 0.6414" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:02:57.064324: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 60ms/step - bce: 0.0596 - loss: 0.7009 - mse: 0.6414 - val_val_bce: 0.0573 - val_val_loss: 0.6990 - val_val_mse: 0.6417\n", + "Epoch 9/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 73ms/step - bce: 0.0559 - loss: 0.6972 - mse: 0.6413 - val_val_bce: 0.0546 - val_val_loss: 0.6963 - val_val_mse: 0.6417\n", + "Epoch 10/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 51ms/step - bce: 0.0537 - loss: 0.6950 - mse: 0.6413 - val_val_bce: 0.0527 - val_val_loss: 0.6944 - val_val_mse: 0.6417\n", + "Epoch 11/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 36ms/step - bce: 0.0521 - loss: 0.6934 - mse: 0.6413" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:03:27.419260: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 45ms/step - bce: 0.0521 - loss: 0.6934 - mse: 0.6414 - val_val_bce: 0.0513 - val_val_loss: 0.6930 - val_val_mse: 0.6417\n", + "Epoch 12/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 54ms/step - bce: 0.0508 - loss: 0.6921 - mse: 0.6413 - val_val_bce: 0.0501 - val_val_loss: 0.6918 - val_val_mse: 0.6417\n", + "Epoch 13/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 71ms/step - bce: 0.0495 - loss: 0.6909 - mse: 0.6413 - val_val_bce: 0.0489 - val_val_loss: 0.6906 - val_val_mse: 0.6417\n", + "Epoch 14/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 50ms/step - bce: 0.0484 - loss: 0.6897 - mse: 0.6413 - val_val_bce: 0.0477 - val_val_loss: 0.6894 - val_val_mse: 0.6417\n", + "Epoch 15/100\n", + "\u001b[1m 1/149\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:11\u001b[0m 890ms/step - bce: 0.0478 - loss: 0.6892 - mse: 0.6414" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:03:58.020487: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 54ms/step - bce: 0.0471 - loss: 0.6885 - mse: 0.6413 - val_val_bce: 0.0464 - val_val_loss: 0.6881 - val_val_mse: 0.6417\n", + "Epoch 16/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 51ms/step - bce: 0.0458 - loss: 0.6871 - mse: 0.6413 - val_val_bce: 0.0449 - val_val_loss: 0.6866 - val_val_mse: 0.6417\n", + "Epoch 17/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 51ms/step - bce: 0.0442 - loss: 0.6855 - mse: 0.6413 - val_val_bce: 0.0432 - val_val_loss: 0.6849 - val_val_mse: 0.6417\n", + "Epoch 18/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 40ms/step - bce: 0.0424 - loss: 0.6837 - mse: 0.6413" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:04:30.877773: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 68ms/step - bce: 0.0424 - loss: 0.6837 - mse: 0.6413 - val_val_bce: 0.0412 - val_val_loss: 0.6829 - val_val_mse: 0.6417\n", + "Epoch 19/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 51ms/step - bce: 0.0402 - loss: 0.6816 - mse: 0.6414 - val_val_bce: 0.0389 - val_val_loss: 0.6806 - val_val_mse: 0.6417\n", + "Epoch 20/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 47ms/step - bce: 0.0378 - loss: 0.6792 - mse: 0.6414 - val_val_bce: 0.0365 - val_val_loss: 0.6783 - val_val_mse: 0.6418\n", + "Epoch 21/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 53ms/step - bce: 0.0352 - loss: 0.6749 - mse: 0.6397 - val_val_bce: 0.0344 - val_val_loss: 0.6624 - val_val_mse: 0.6279\n", + "Epoch 22/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 40ms/step - bce: 0.0328 - loss: 0.6529 - mse: 0.6200" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:05:06.298897: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0328 - loss: 0.6528 - mse: 0.6200 - val_val_bce: 0.0318 - val_val_loss: 0.6425 - val_val_mse: 0.6108\n", + "Epoch 23/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 46ms/step - bce: 0.0306 - loss: 0.6319 - mse: 0.6013 - val_val_bce: 0.0299 - val_val_loss: 0.6204 - val_val_mse: 0.5905\n", + "Epoch 24/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 73ms/step - bce: 0.0290 - loss: 0.6119 - mse: 0.5830 - val_val_bce: 0.0286 - val_val_loss: 0.6010 - val_val_mse: 0.5725\n", + "Epoch 25/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 42ms/step - bce: 0.0277 - loss: 0.5905 - mse: 0.5628" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:05:36.381304: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 67ms/step - bce: 0.0277 - loss: 0.5904 - mse: 0.5627 - val_val_bce: 0.0275 - val_val_loss: 0.5843 - val_val_mse: 0.5569\n", + "Epoch 26/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 53ms/step - bce: 0.0266 - loss: 0.5766 - mse: 0.5500 - val_val_bce: 0.0265 - val_val_loss: 0.5699 - val_val_mse: 0.5434\n", + "Epoch 27/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 46ms/step - bce: 0.0257 - loss: 0.5602 - mse: 0.5346 - val_val_bce: 0.0255 - val_val_loss: 0.5527 - val_val_mse: 0.5272\n", + "Epoch 28/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 69ms/step - bce: 0.0247 - loss: 0.5400 - mse: 0.5153 - val_val_bce: 0.0246 - val_val_loss: 0.5290 - val_val_mse: 0.5044\n", + "Epoch 29/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:06:06.567263: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0238 - loss: 0.5173 - mse: 0.4935 - val_val_bce: 0.0237 - val_val_loss: 0.5074 - val_val_mse: 0.4837\n", + "Epoch 30/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 55ms/step - bce: 0.0229 - loss: 0.4985 - mse: 0.4756 - val_val_bce: 0.0228 - val_val_loss: 0.4863 - val_val_mse: 0.4635\n", + "Epoch 31/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 48ms/step - bce: 0.0220 - loss: 0.4781 - mse: 0.4561 - val_val_bce: 0.0219 - val_val_loss: 0.4655 - val_val_mse: 0.4437\n", + "Epoch 32/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 37ms/step - bce: 0.0211 - loss: 0.4585 - mse: 0.4374" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:06:38.496406: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 46ms/step - bce: 0.0211 - loss: 0.4584 - mse: 0.4373 - val_val_bce: 0.0210 - val_val_loss: 0.4447 - val_val_mse: 0.4237\n", + "Epoch 33/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 71ms/step - bce: 0.0202 - loss: 0.4422 - mse: 0.4220 - val_val_bce: 0.0201 - val_val_loss: 0.4301 - val_val_mse: 0.4099\n", + "Epoch 34/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 48ms/step - bce: 0.0194 - loss: 0.4254 - mse: 0.4060 - val_val_bce: 0.0193 - val_val_loss: 0.4120 - val_val_mse: 0.3926\n", + "Epoch 35/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 46ms/step - bce: 0.0186 - loss: 0.4068 - mse: 0.3882 - val_val_bce: 0.0185 - val_val_loss: 0.3941 - val_val_mse: 0.3756\n", + "Epoch 36/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 37ms/step - bce: 0.0178 - loss: 0.3852 - mse: 0.3675" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:07:15.050663: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 48ms/step - bce: 0.0178 - loss: 0.3852 - mse: 0.3674 - val_val_bce: 0.0177 - val_val_loss: 0.3701 - val_val_mse: 0.3524\n", + "Epoch 37/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 52ms/step - bce: 0.0170 - loss: 0.3621 - mse: 0.3451 - val_val_bce: 0.0169 - val_val_loss: 0.3485 - val_val_mse: 0.3316\n", + "Epoch 38/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 63ms/step - bce: 0.0162 - loss: 0.3404 - mse: 0.3242 - val_val_bce: 0.0162 - val_val_loss: 0.3243 - val_val_mse: 0.3081\n", + "Epoch 39/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 38ms/step - bce: 0.0156 - loss: 0.3194 - mse: 0.3038" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:07:46.817465: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 48ms/step - bce: 0.0155 - loss: 0.3192 - mse: 0.3037 - val_val_bce: 0.0155 - val_val_loss: 0.3018 - val_val_mse: 0.2863\n", + "Epoch 40/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 54ms/step - bce: 0.0149 - loss: 0.2998 - mse: 0.2849 - val_val_bce: 0.0149 - val_val_loss: 0.2841 - val_val_mse: 0.2692\n", + "Epoch 41/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 48ms/step - bce: 0.0143 - loss: 0.2820 - mse: 0.2677 - val_val_bce: 0.0143 - val_val_loss: 0.2665 - val_val_mse: 0.2521\n", + "Epoch 42/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 67ms/step - bce: 0.0138 - loss: 0.2665 - mse: 0.2528 - val_val_bce: 0.0138 - val_val_loss: 0.2528 - val_val_mse: 0.2390\n", + "Epoch 43/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 38ms/step - bce: 0.0133 - loss: 0.2522 - mse: 0.2389" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:08:22.970679: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 52ms/step - bce: 0.0133 - loss: 0.2523 - mse: 0.2390 - val_val_bce: 0.0133 - val_val_loss: 0.2398 - val_val_mse: 0.2265\n", + "Epoch 44/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 50ms/step - bce: 0.0128 - loss: 0.2397 - mse: 0.2269 - val_val_bce: 0.0129 - val_val_loss: 0.2295 - val_val_mse: 0.2166\n", + "Epoch 45/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 60ms/step - bce: 0.0124 - loss: 0.2287 - mse: 0.2163 - val_val_bce: 0.0125 - val_val_loss: 0.2214 - val_val_mse: 0.2089\n", + "Epoch 46/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 72ms/step - bce: 0.0120 - loss: 0.2186 - mse: 0.2066 - val_val_bce: 0.0121 - val_val_loss: 0.2114 - val_val_mse: 0.1993\n", + "Epoch 47/100\n", + "\u001b[1m 1/149\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:00\u001b[0m 813ms/step - bce: 0.0119 - loss: 0.2130 - mse: 0.2011" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:08:53.486640: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 48ms/step - bce: 0.0117 - loss: 0.2103 - mse: 0.1986 - val_val_bce: 0.0118 - val_val_loss: 0.2021 - val_val_mse: 0.1903\n", + "Epoch 48/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 50ms/step - bce: 0.0114 - loss: 0.2028 - mse: 0.1914 - val_val_bce: 0.0115 - val_val_loss: 0.1948 - val_val_mse: 0.1833\n", + "Epoch 49/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 56ms/step - bce: 0.0111 - loss: 0.1956 - mse: 0.1845 - val_val_bce: 0.0113 - val_val_loss: 0.1896 - val_val_mse: 0.1783\n", + "Epoch 50/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 41ms/step - bce: 0.0108 - loss: 0.1895 - mse: 0.1786" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:09:25.459141: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 50ms/step - bce: 0.0108 - loss: 0.1894 - mse: 0.1786 - val_val_bce: 0.0110 - val_val_loss: 0.1845 - val_val_mse: 0.1735\n", + "Epoch 51/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 49ms/step - bce: 0.0106 - loss: 0.1836 - mse: 0.1730 - val_val_bce: 0.0108 - val_val_loss: 0.1784 - val_val_mse: 0.1676\n", + "Epoch 52/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 69ms/step - bce: 0.0104 - loss: 0.1787 - mse: 0.1683 - val_val_bce: 0.0106 - val_val_loss: 0.1739 - val_val_mse: 0.1634\n", + "Epoch 53/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 40ms/step - bce: 0.0102 - loss: 0.1741 - mse: 0.1639" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:09:57.497512: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0102 - loss: 0.1741 - mse: 0.1639 - val_val_bce: 0.0104 - val_val_loss: 0.1707 - val_val_mse: 0.1603\n", + "Epoch 54/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 65ms/step - bce: 0.0100 - loss: 0.1701 - mse: 0.1600 - val_val_bce: 0.0102 - val_val_loss: 0.1673 - val_val_mse: 0.1570\n", + "Epoch 55/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 54ms/step - bce: 0.0098 - loss: 0.1662 - mse: 0.1563 - val_val_bce: 0.0101 - val_val_loss: 0.1640 - val_val_mse: 0.1540\n", + "Epoch 56/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 39ms/step - bce: 0.0097 - loss: 0.1628 - mse: 0.1532" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:10:28.105156: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 53ms/step - bce: 0.0097 - loss: 0.1628 - mse: 0.1532 - val_val_bce: 0.0099 - val_val_loss: 0.1615 - val_val_mse: 0.1516\n", + "Epoch 57/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 50ms/step - bce: 0.0095 - loss: 0.1597 - mse: 0.1501 - val_val_bce: 0.0098 - val_val_loss: 0.1581 - val_val_mse: 0.1483\n", + "Epoch 58/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 69ms/step - bce: 0.0094 - loss: 0.1568 - mse: 0.1474 - val_val_bce: 0.0096 - val_val_loss: 0.1552 - val_val_mse: 0.1456\n", + "Epoch 59/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 40ms/step - bce: 0.0092 - loss: 0.1541 - mse: 0.1448" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:10:58.861819: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 48ms/step - bce: 0.0092 - loss: 0.1541 - mse: 0.1448 - val_val_bce: 0.0095 - val_val_loss: 0.1532 - val_val_mse: 0.1437\n", + "Epoch 60/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 68ms/step - bce: 0.0091 - loss: 0.1517 - mse: 0.1426 - val_val_bce: 0.0094 - val_val_loss: 0.1518 - val_val_mse: 0.1424\n", + "Epoch 61/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 66ms/step - bce: 0.0090 - loss: 0.1492 - mse: 0.1402 - val_val_bce: 0.0092 - val_val_loss: 0.1494 - val_val_mse: 0.1401\n", + "Epoch 62/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 41ms/step - bce: 0.0089 - loss: 0.1470 - mse: 0.1381" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:11:29.181796: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 54ms/step - bce: 0.0089 - loss: 0.1470 - mse: 0.1381 - val_val_bce: 0.0091 - val_val_loss: 0.1477 - val_val_mse: 0.1385\n", + "Epoch 63/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 43ms/step - bce: 0.0088 - loss: 0.1449 - mse: 0.1361" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:11:38.259062: I tensorflow/core/framework/local_rendezvous.cc:407] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 53ms/step - bce: 0.0088 - loss: 0.1448 - mse: 0.1360 - val_val_bce: 0.0090 - val_val_loss: 0.1466 - val_val_mse: 0.1376\n", + "Epoch 64/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 61ms/step - bce: 0.0087 - loss: 0.1428 - mse: 0.1342 - val_val_bce: 0.0089 - val_val_loss: 0.1450 - val_val_mse: 0.1360\n", + "Epoch 65/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 57ms/step - bce: 0.0086 - loss: 0.1412 - mse: 0.1326 - val_val_bce: 0.0088 - val_val_loss: 0.1449 - val_val_mse: 0.1361\n", + "Epoch 66/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 42ms/step - bce: 0.0085 - loss: 0.1397 - mse: 0.1312" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:12:05.123612: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 51ms/step - bce: 0.0085 - loss: 0.1396 - mse: 0.1311 - val_val_bce: 0.0088 - val_val_loss: 0.1425 - val_val_mse: 0.1337\n", + "Epoch 67/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 69ms/step - bce: 0.0084 - loss: 0.1381 - mse: 0.1297 - val_val_bce: 0.0087 - val_val_loss: 0.1407 - val_val_mse: 0.1320\n", + "Epoch 68/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 56ms/step - bce: 0.0083 - loss: 0.1367 - mse: 0.1284 - val_val_bce: 0.0086 - val_val_loss: 0.1396 - val_val_mse: 0.1310\n", + "Epoch 69/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 41ms/step - bce: 0.0082 - loss: 0.1351 - mse: 0.1269" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:12:36.034351: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 50ms/step - bce: 0.0083 - loss: 0.1352 - mse: 0.1269 - val_val_bce: 0.0085 - val_val_loss: 0.1378 - val_val_mse: 0.1293\n", + "Epoch 70/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0082 - loss: 0.1337 - mse: 0.1255 - val_val_bce: 0.0085 - val_val_loss: 0.1367 - val_val_mse: 0.1282\n", + "Epoch 71/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0081 - loss: 0.1325 - mse: 0.1244 - val_val_bce: 0.0084 - val_val_loss: 0.1353 - val_val_mse: 0.1269\n", + "Epoch 72/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 55ms/step - bce: 0.0081 - loss: 0.1311 - mse: 0.1231 - val_val_bce: 0.0084 - val_val_loss: 0.1336 - val_val_mse: 0.1253\n", + "Epoch 73/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 45ms/step - bce: 0.0080 - loss: 0.1298 - mse: 0.1218" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:13:12.145080: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 54ms/step - bce: 0.0080 - loss: 0.1299 - mse: 0.1219 - val_val_bce: 0.0083 - val_val_loss: 0.1330 - val_val_mse: 0.1246\n", + "Epoch 74/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0079 - loss: 0.1287 - mse: 0.1208 - val_val_bce: 0.0083 - val_val_loss: 0.1319 - val_val_mse: 0.1236\n", + "Epoch 75/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 74ms/step - bce: 0.0079 - loss: 0.1274 - mse: 0.1195 - val_val_bce: 0.0082 - val_val_loss: 0.1300 - val_val_mse: 0.1218\n", + "Epoch 76/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 62ms/step - bce: 0.0078 - loss: 0.1263 - mse: 0.1184 - val_val_bce: 0.0082 - val_val_loss: 0.1291 - val_val_mse: 0.1209\n", + "Epoch 77/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:13:42.353342: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0078 - loss: 0.1251 - mse: 0.1173 - val_val_bce: 0.0081 - val_val_loss: 0.1279 - val_val_mse: 0.1198\n", + "Epoch 78/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 73ms/step - bce: 0.0077 - loss: 0.1241 - mse: 0.1163 - val_val_bce: 0.0081 - val_val_loss: 0.1263 - val_val_mse: 0.1183\n", + "Epoch 79/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 64ms/step - bce: 0.0077 - loss: 0.1228 - mse: 0.1151 - val_val_bce: 0.0080 - val_val_loss: 0.1257 - val_val_mse: 0.1177\n", + "Epoch 80/100\n", + "\u001b[1m 3/149\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 34ms/step - bce: 0.0076 - loss: 0.1206 - mse: 0.1130 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:14:12.973565: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0077 - loss: 0.1220 - mse: 0.1143 - val_val_bce: 0.0080 - val_val_loss: 0.1239 - val_val_mse: 0.1159\n", + "Epoch 81/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 54ms/step - bce: 0.0076 - loss: 0.1210 - mse: 0.1134 - val_val_bce: 0.0080 - val_val_loss: 0.1236 - val_val_mse: 0.1157\n", + "Epoch 82/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 57ms/step - bce: 0.0076 - loss: 0.1199 - mse: 0.1123 - val_val_bce: 0.0079 - val_val_loss: 0.1230 - val_val_mse: 0.1150\n", + "Epoch 83/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 43ms/step - bce: 0.0075 - loss: 0.1190 - mse: 0.1114" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:14:46.121542: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 61ms/step - bce: 0.0075 - loss: 0.1190 - mse: 0.1115 - val_val_bce: 0.0079 - val_val_loss: 0.1225 - val_val_mse: 0.1147\n", + "Epoch 84/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 47ms/step - bce: 0.0075 - loss: 0.1180 - mse: 0.1105 - val_val_bce: 0.0078 - val_val_loss: 0.1217 - val_val_mse: 0.1138\n", + "Epoch 85/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 57ms/step - bce: 0.0075 - loss: 0.1171 - mse: 0.1096 - val_val_bce: 0.0078 - val_val_loss: 0.1214 - val_val_mse: 0.1136\n", + "Epoch 86/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 50ms/step - bce: 0.0074 - loss: 0.1163 - mse: 0.1089 - val_val_bce: 0.0078 - val_val_loss: 0.1203 - val_val_mse: 0.1125\n", + "Epoch 87/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 42ms/step - bce: 0.0074 - loss: 0.1154 - mse: 0.1080" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:15:21.082623: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 65ms/step - bce: 0.0074 - loss: 0.1153 - mse: 0.1079 - val_val_bce: 0.0077 - val_val_loss: 0.1193 - val_val_mse: 0.1116\n", + "Epoch 88/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 47ms/step - bce: 0.0074 - loss: 0.1145 - mse: 0.1072 - val_val_bce: 0.0077 - val_val_loss: 0.1184 - val_val_mse: 0.1107\n", + "Epoch 89/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m12s\u001b[0m 73ms/step - bce: 0.0073 - loss: 0.1137 - mse: 0.1064 - val_val_bce: 0.0077 - val_val_loss: 0.1179 - val_val_mse: 0.1103\n", + "Epoch 90/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 42ms/step - bce: 0.0073 - loss: 0.1130 - mse: 0.1057" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:15:51.252224: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 51ms/step - bce: 0.0073 - loss: 0.1129 - mse: 0.1056 - val_val_bce: 0.0077 - val_val_loss: 0.1163 - val_val_mse: 0.1086\n", + "Epoch 91/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 54ms/step - bce: 0.0073 - loss: 0.1123 - mse: 0.1050 - val_val_bce: 0.0076 - val_val_loss: 0.1161 - val_val_mse: 0.1085\n", + "Epoch 92/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 55ms/step - bce: 0.0072 - loss: 0.1114 - mse: 0.1041 - val_val_bce: 0.0076 - val_val_loss: 0.1157 - val_val_mse: 0.1081\n", + "Epoch 93/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 41ms/step - bce: 0.0072 - loss: 0.1108 - mse: 0.1036" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:16:22.049275: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 50ms/step - bce: 0.0072 - loss: 0.1108 - mse: 0.1036 - val_val_bce: 0.0076 - val_val_loss: 0.1147 - val_val_mse: 0.1071\n", + "Epoch 94/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 65ms/step - bce: 0.0072 - loss: 0.1102 - mse: 0.1030 - val_val_bce: 0.0076 - val_val_loss: 0.1148 - val_val_mse: 0.1072\n", + "Epoch 95/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 56ms/step - bce: 0.0072 - loss: 0.1095 - mse: 0.1024 - val_val_bce: 0.0075 - val_val_loss: 0.1137 - val_val_mse: 0.1061\n", + "Epoch 96/100\n", + "\u001b[1m148/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 40ms/step - bce: 0.0072 - loss: 0.1089 - mse: 0.1017" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:16:52.076290: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 49ms/step - bce: 0.0072 - loss: 0.1089 - mse: 0.1017 - val_val_bce: 0.0075 - val_val_loss: 0.1132 - val_val_mse: 0.1057\n", + "Epoch 97/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 65ms/step - bce: 0.0071 - loss: 0.1082 - mse: 0.1011 - val_val_bce: 0.0075 - val_val_loss: 0.1119 - val_val_mse: 0.1044\n", + "Epoch 98/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 46ms/step - bce: 0.0071 - loss: 0.1075 - mse: 0.1004 - val_val_bce: 0.0075 - val_val_loss: 0.1119 - val_val_mse: 0.1045\n", + "Epoch 99/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 29ms/step - bce: 0.0071 - loss: 0.1072 - mse: 0.1001 - val_val_bce: 0.0075 - val_val_loss: 0.1113 - val_val_mse: 0.1039\n", + "Epoch 100/100\n", + "\u001b[1m149/149\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 28ms/step - bce: 0.0071 - loss: 0.1066 - mse: 0.0995 - val_val_bce: 0.0074 - val_val_loss: 0.1111 - val_val_mse: 0.1036\n" + ] + } + ], + "source": [ + "history = model.fit(\n", + " train_ds,\n", + " validation_data=val_ds,\n", + " epochs=100\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "a1e187b4", + "metadata": {}, + "outputs": [], + "source": [ + "# import matplotlib.pyplot as plt\n", + "\n", + "# def plot_training_history(history):\n", + "# \"\"\"\n", + "# Plots the training and validation losses against epochs in a log scale,\n", + "# and the loss against the learning rate.\n", + "\n", + "# Parameters:\n", + "# - history: History object returned by model.fit, containing training metrics.\n", + "# \"\"\"\n", + "# epochs = range(len(history.history['loss']))\n", + "\n", + "# # Plot training and validation loss on a log scale\n", + "# plt.figure(figsize=(14, 6))\n", + " \n", + "# # Loss plot (log scale)\n", + "# plt.subplot(1, 2, 1)\n", + "# plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + "# plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + "# plt.yscale('log') # Logarithmic scale for loss\n", + "# plt.xlabel('Epochs')\n", + "# plt.ylabel('Loss (log scale)')\n", + "# plt.title('Training and Validation Loss (Log Scale)')\n", + "# plt.legend()\n", + "# plot_training_history(history)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "6413960c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_training_history(history):\n", + " plt.figure(figsize=(18, 6))\n", + " \n", + " # Total Loss (log scale)\n", + " plt.subplot(1, 3, 1)\n", + " plt.semilogy(history.history['loss'], 'b-', label='Train')\n", + " plt.semilogy(history.history['val_val_loss'], 'r-', label='Validation')\n", + " plt.title('Total Loss (Log Scale)')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Loss')\n", + " plt.legend()\n", + " plt.grid(True, which=\"both\", ls=\"-\")\n", + " \n", + " # BCE Loss (log scale)\n", + " plt.subplot(1, 3, 2)\n", + " plt.semilogy(history.history['bce'], 'b-', label='Train')\n", + " plt.semilogy(history.history['val_val_bce'], 'r-', label='Validation')\n", + " plt.title('BCE Loss (Log Scale)')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('BCE')\n", + " plt.legend()\n", + " plt.grid(True, which=\"both\", ls=\"-\")\n", + " \n", + " # MSE Loss (log scale)\n", + " plt.subplot(1, 3, 3)\n", + " plt.semilogy(history.history['mse'], 'b-', label='Train')\n", + " plt.semilogy(history.history['val_val_mse'], 'r-', label='Validation')\n", + " plt.title('MSE Loss (Log Scale)')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('MSE')\n", + " plt.legend()\n", + " plt.grid(True, which=\"both\", ls=\"-\")\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_training_history(history)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef082776", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" + ] + } + ], + "source": [ + "# model.save(\"/home/da886/ComputerVision_OD_Electron_Counting/Trained_Weights/RF_withPermutation_unweighted.h5\")" + ] + }, + { + "cell_type": "markdown", + "id": "a1c27d40", + "metadata": {}, + "source": [ + "### Sample Image and predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "f31d4a03", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1632990/3646996811.py:27: UserWarning: You passed both c and facecolor/facecolors for the markers. c has precedence over facecolor/facecolors. This behavior may change in the future.\n", + " plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "idx = np.random.randint(len(X_images))\n", + "# idx =9739\n", + "img = X_images[idx,...,0]\n", + "gt_lbl = y_labels[idx]\n", + "pred_lbl = model.predict(img[None],verbose=0)[0]\n", + "\n", + "\n", + "def unpack(lbl_tensor, threshold=0.5):\n", + " \n", + " r,c,k = np.where(lbl_tensor[...,0] > threshold)\n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + " x = x0 + lbl_tensor[r,c,k,1]*RF_SIZE\n", + " y = y0 + lbl_tensor[r,c,k,2]*RF_SIZE\n", + " return x, y\n", + "\n", + "x_gt, y_gt = unpack(gt_lbl, threshold=0)\n", + "x_pr, y_pr = unpack(pred_lbl, threshold=0.5)\n", + "\n", + "plt.figure(figsize=(12,12))\n", + "plt.imshow(img,cmap='gray', origin=\"upper\")\n", + "# plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "plt.scatter(x_gt, y_gt, c=\"red\", marker=\"x\", s=30, label=\"GT\")\n", + "plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "plt.title(f\"Frame {idx}\")\n", + "plt.legend(loc=\"lower right\")\n", + "# plt.xlim(0,63); plt.ylim(63,0); plt.show()\n", + "plt.xlim(0,255); plt.ylim(255,0); plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "c163b1a1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No cells with 2 hit(s); skipping.\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def plot_probability_distributions(gt_lbl, pred_lbl, threshold=0.5):\n", + " \"\"\"\n", + " Show log-scaled histograms of predicted probabilities (p̂) for cells\n", + " with 0, 1, and 2 ground-truth hits.\n", + "\n", + " Parameters\n", + " ----------\n", + " gt_lbl : (128,128,K,3) ground-truth label tensor\n", + " pred_lbl : (128,128,K,3) model prediction tensor\n", + " threshold: float probability threshold used by gating (default 0.5)\n", + " \"\"\"\n", + " K = gt_lbl.shape[2] # number of slots per cell\n", + "\n", + " # ─── flatten cell → slot axis ─────────────────────────────────────────\n", + " p_true = gt_lbl [ ..., 0].reshape(-1, K) # (N,K)\n", + " p_pred = pred_lbl[..., 0].reshape(-1, K) # (N,K)\n", + " num_hits = (p_true > 0.5).sum(axis=1) # (N,)\n", + "\n", + " # collect predicted probabilities for each group\n", + " groups = {h: p_pred[num_hits == h].ravel() for h in (0, 1, 2)}\n", + "\n", + " # ─── one chart per hit-count (no sub-plots → matches training) ───────\n", + " for h in (0, 1, 2):\n", + " if groups[h].size == 0:\n", + " print(f\"No cells with {h} hit(s); skipping.\")\n", + " continue\n", + "\n", + " plt.figure(figsize=(6,4))\n", + " plt.hist(groups[h],\n", + " bins = np.linspace(0, 1, 51),\n", + " log = True, # y-axis on log scale\n", + " edgecolor='black')\n", + " plt.axvline(threshold, color='red', linestyle='--', linewidth=1)\n", + " plt.title(f\"Predicted probability distribution – {h}-hit cells\")\n", + " plt.xlabel(\"predicted probability (p̂)\")\n", + " plt.ylabel(\"count (log scale)\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# ─── usage example ───────────────────────────────────────────────────────\n", + "# assumes you already have gt_lbl & pred_lbl (K = 2) in memory\n", + "plot_probability_distributions(gt_lbl, pred_lbl, threshold=0.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "15c46674", + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import pandas as pd\n", + "# import ace_tools_open as tools\n", + "# import tensorflow as tf\n", + "\n", + "# # ─── Hyperparameters ──────────────────────────────────────────\n", + "# eps = 1e-6\n", + "# λ_xy = 1.0 # weight on the MSE term\n", + "# # ──────────────────────────────────────────────────────────────\n", + "\n", + "# def compute_direct_loss(y_true, y_pred):\n", + "# \"\"\"Computes losses without any permutation matching\"\"\"\n", + "# p_true = y_true[..., 0] # (H,W,K)\n", + "# xy_true = y_true[..., 1:] # (H,W,K,2)\n", + "# p_pred = y_pred[..., 0] # (H,W,K)\n", + "# xy_pred = y_pred[..., 1:] # (H,W,K,2)\n", + " \n", + "# H, W, K = p_true.shape\n", + "# N = H * W\n", + " \n", + "# # Flatten tensors\n", + "# p_t = p_true.reshape(-1, K) # (N,K)\n", + "# xy_t = xy_true.reshape(-1, K, 2) # (N,K,2)\n", + "# p_p = p_pred.reshape(-1, K) # (N,K)\n", + "# xy_p = xy_pred.reshape(-1, K, 2) # (N,K,2)\n", + " \n", + "# # 1. BCE in natural order\n", + "# bce = tf.keras.losses.binary_crossentropy(p_t, p_p).numpy() # (N,)\n", + " \n", + "# # 2. MSE in natural order\n", + "# mask = (p_t > 0.5).astype(np.float32)[..., np.newaxis] # (N,K,1)\n", + "# se = np.sum((xy_t - xy_p)**2, axis=2) # (N,K)\n", + "# mse = np.sum(se * mask.squeeze(), axis=1) / (np.sum(mask, axis=(1,2)) + eps) # (N,)\n", + " \n", + "# total_loss = bce + λ_xy * mse\n", + " \n", + "# return total_loss, bce, mse\n", + "\n", + "# # ─── Analysis Execution ───────────────────────────────────────\n", + "# img = X_images[idx, ..., 0]\n", + "# gt_lbl = y_labels[idx] # (H,W,K,3)\n", + "# pred_lbl = model.predict(img[None], verbose=0)[0] # (H,W,K,3)\n", + "\n", + "# # Compute losses\n", + "# total_loss, bce, mse = compute_direct_loss(gt_lbl, pred_lbl)\n", + "\n", + "# # Create DataFrame\n", + "# H, W, K = gt_lbl.shape[:3]\n", + "# rows_idx, cols_idx = np.unravel_index(np.arange(H*W), (H, W))\n", + "# num_hits = (gt_lbl[..., 0] > 0.5).reshape(-1, K).sum(axis=1)\n", + "\n", + "# df_summary = pd.DataFrame({\n", + "# \"row\": rows_idx,\n", + "# \"col\": cols_idx,\n", + "# \"num_hits\": num_hits,\n", + "# \"BCE\": bce,\n", + "# \"MSE\": mse,\n", + "# \"combined\": total_loss\n", + "# })\n", + "\n", + "# def unpack_slots(selected):\n", + "# \"\"\"Unpack slot details in natural order\"\"\"\n", + "# records = []\n", + "# for _, cell in selected.iterrows():\n", + "# r, c = int(cell.row), int(cell.col)\n", + "# y_t = gt_lbl[r, c] # (K,3)\n", + "# y_p = pred_lbl[r, c] # (K,3)\n", + " \n", + "# for k in range(K):\n", + "# records.append({\n", + "# \"row\": r, \"col\": c, \"slot\": k,\n", + "# \"GT_p\": float(y_t[k, 0]),\n", + "# \"GT_x\": float(y_t[k, 1]), \n", + "# \"GT_y\": float(y_t[k, 2]),\n", + "# \"PR_p\": float(y_p[k, 0]),\n", + "# \"PR_x\": float(y_p[k, 1]), \n", + "# \"PR_y\": float(y_p[k, 2]),\n", + "# # \"dist\": np.sqrt((y_t[k,1]-y_p[k,1])**2 + (y_t[k,2]-y_p[k,2])**2) if y_t[k,0] > 0.5 else np.nan,\n", + "# \"cell_BCE\": float(cell.BCE) if k==0 else \"\",\n", + "# \"cell_MSE\": float(cell.MSE) if k==0 else \"\",\n", + "# \"combined\": float(cell.combined) if k==0 else \"\",\n", + "# })\n", + "# return pd.DataFrame(records)\n", + "\n", + "# # Generate sample tables\n", + "# tables = {}\n", + "# for hits in (1, 2):\n", + "# group = df_summary[df_summary['num_hits'] == hits]\n", + "# if not group.empty:\n", + "# best5 = group.nsmallest(5, 'combined')\n", + "# worst5 = group.nlargest(5, 'combined')\n", + "# tables[f'hits={hits} BEST'] = unpack_slots(best5)\n", + "# tables[f'hits={hits} WORST'] = unpack_slots(worst5)\n", + "\n", + "# # Display results\n", + "# for title, df in tables.items():\n", + "# tools.display_dataframe_to_user(title, df)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "id": "367c60f2", + "metadata": {}, + "outputs": [], + "source": [ + "mytrue = np.array([[1,0.625, 0.625],[0,0,0]])\n", + "mypred= np.array([[0.980844,0.609007,0.576857],[0.000387,0,0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "42b76663", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.00064338185\n" + ] + } + ], + "source": [ + "mse = tf.keras.losses.MeanSquaredError()\n", + "loss2 = mse(mytrue[...,1:], mypred[...,1:])\n", + "print(loss2.numpy())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "b09cfe59", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_coords = tf.reduce_mean(tf.square(mytrue[...,1:] - mypred[...,1:]))\n", + "loss_coords" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "c82eadb2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1. , 0.980844])" + ] + }, + "execution_count": 112, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mytrue[...,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "4fff6ae9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_prob = tf.keras.losses.binary_crossentropy(mytrue[...,0], mypred[...,0])\n", + "# loss_prob = tf.reduce_mean(loss_prob)\n", + "loss_prob" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "36848ab5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-20 15:25:25.287353: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=1 BEST\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=1 WORST\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "import pandas as pd\n", + "import ace_tools_open as tools\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from itertools import permutations\n", + "\n", + "# ─── constants copied from the model ──────────────────────────\n", + "HIT_WEIGHTS = {1: 1, 2: 1} # same as RF8Detector.hit_weights\n", + "eps = 1e-6\n", + "# ──────────────────────────────────────────────────────────────\n", + "\n", + "# def compute_analysis_loss(y_true, y_pred):\n", + "# \"\"\"\n", + "# Replicates RF8Detector.compute_permuted_loss *per cell*.\n", + "\n", + "# Returns\n", + "# -------\n", + "# total : (N,) weighted BCE + weighted MSE\n", + "# weighted_bce, weighted_mse, best_perm : (N,), (N,), (N,K)\n", + "# \"\"\"\n", + "# # shapes\n", + "# H, W, K, _ = y_true.shape\n", + "# N = H * W # cells in the image\n", + "# PERMS = np.array(list(permutations(range(K))), dtype=np.int32) # (P,K)\n", + "\n", + "# # flatten spatial dims -------------------------------------------------\n", + "# p_t = y_true[..., 0].reshape(N, K) # (N,K)\n", + "# xy_t = y_true[..., 1:].reshape(N, K, 2) # (N,K,2)\n", + "# p_p = y_pred[..., 0].reshape(N, K)\n", + "# xy_p = y_pred[..., 1:].reshape(N, K, 2)\n", + "\n", + "# # 1) BCE in natural order ----------------------------------------------\n", + "# bce = tf.keras.losses.binary_crossentropy(p_t, p_p).numpy() # (N,)\n", + "\n", + "# # 2) permutation-optimised MSE -----------------------------------------\n", + "# # xy_p → (N,1,K,2) so we can gather K coords for every perm at once\n", + "# xy_p_exp = xy_p[:, None] # (N,1,K,2)\n", + "# # PERMS → (1,P,K,1) so broadcasting matches xy_p_exp\n", + "# perm_idx = PERMS[None, :, :, None] # (1,P,K,1)\n", + "# xy_p_perm = np.take_along_axis(xy_p_exp, perm_idx, axis=2) # (N,P,K,2)\n", + "\n", + "# # squared error per slot & perm\n", + "# se = np.sum((xy_t[:, None] - xy_p_perm) ** 2, axis=-1) # (N,P,K)\n", + "# # se = np.mean((xy_t[:, None] - xy_p_perm) ** 2, axis=-1) ##################################### This part only does what Tensorflow's MSE does and only is accurate when there are 2 hits\n", + "\n", + "# # hit mask (N,1,K) so it broadcasts over perms\n", + "# mask = (p_t > 0.5).astype(np.float32)[:, None, :] # (N,1,K)\n", + "# mse_per_perm = np.sum(se * mask, axis=2) / (np.sum(mask, axis=2) + eps) # (N,P)\n", + "\n", + "# best_idx = np.argmin(mse_per_perm, axis=1) # (N,)\n", + "# best_mse = mse_per_perm[np.arange(N), best_idx] # (N,)\n", + "# best_perm = PERMS[best_idx] # (N,K)\n", + "\n", + "# # 3) hit-count weighting ----------------------------------------------\n", + "# num_hits = (p_t > 0.5).sum(axis=1) # (N,)\n", + "# weights = np.where(\n", + "# num_hits == 1, HIT_WEIGHTS[1],\n", + "# np.where(num_hits == 2, HIT_WEIGHTS[2], 1.0)\n", + "# )\n", + "\n", + "# weighted_bce = bce * weights\n", + "# weighted_mse = best_mse * weights\n", + "# total = weighted_bce + weighted_mse # NOTE: no λ_xy in training\n", + "\n", + "# return total, weighted_bce, weighted_mse, best_perm\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from itertools import permutations\n", + "\n", + "eps = 1e-6\n", + "PERMS_CACHE = {} # speeds things up if you call the function many times\n", + "\n", + "def compute_analysis_loss(y_true, y_pred):\n", + " \"\"\"\n", + " Per-cell BCE & permuted MSE, identical to the training logic.\n", + " Returns:\n", + " total (N,) = weighted_bce + weighted_mse\n", + " weighted_bce (N,)\n", + " weighted_mse (N,)\n", + " best_perm (N,K) slot order chosen for MSE\n", + " \"\"\"\n", + " H, W, K, _ = y_true.shape\n", + " N = H * W\n", + "\n", + " # --- permutation list (cached) ---------------------------------------\n", + " if K not in PERMS_CACHE:\n", + " PERMS_CACHE[K] = np.array(list(permutations(range(K))), dtype=np.int32)\n", + " PERMS = PERMS_CACHE[K] # (P,K)\n", + "\n", + " # --- flatten spatial dims --------------------------------------------\n", + " p_t = y_true[..., 0].reshape(N, K) # (N,K)\n", + " xy_t = y_true[..., 1:].reshape(N, K, 2) # (N,K,2)\n", + " p_p = y_pred[..., 0].reshape(N, K)\n", + " xy_p = y_pred[..., 1:].reshape(N, K, 2)\n", + "\n", + " # 1) BCE ---------------------------------------------------------------\n", + " bce = tf.keras.losses.binary_crossentropy(p_t, p_p).numpy() # (N,)\n", + "\n", + " # 2) permuted MSE ------------------------------------------------------\n", + " xy_p_perm = np.take_along_axis(\n", + " xy_p[:, None], # (N,1,K,2)\n", + " PERMS[None, :, :, None], # (1,P,K,1)\n", + " axis=2) # → (N,P,K,2)\n", + "\n", + " se = np.sum( # *** SUM over x & y (no /2)\n", + " (xy_t[:, None] - xy_p_perm) ** 2,\n", + " axis=-1) # (N,P,K)\n", + "\n", + " mask = (p_t > 0.5).astype(np.float32)[:, None] # (N,1,K)\n", + " mse_per_perm = np.sum(se * mask, axis=2) / (np.sum(mask, axis=2) + eps) # (N,P)\n", + "\n", + " best_idx = np.argmin(mse_per_perm, axis=1) # (N,)\n", + " best_mse = mse_per_perm[np.arange(N), best_idx]\n", + " best_perm = PERMS[best_idx]\n", + "\n", + " # 3) hit-count weighting ----------------------------------------------\n", + " num_hits = (p_t > 0.5).sum(axis=1) # (N,)\n", + " weights = np.where(num_hits == 1, HIT_WEIGHTS[1],\n", + " np.where(num_hits == 2, HIT_WEIGHTS[2], 1.0))\n", + "\n", + " weighted_bce = bce * weights # per-cell\n", + " weighted_mse = best_mse * weights\n", + "\n", + " total = weighted_bce + weighted_mse\n", + "\n", + " # (optional) global means exactly like training -----------------------\n", + " mean_bce = weighted_bce.mean() # all cells\n", + " active = num_hits > 0\n", + " mean_mse = weighted_mse[active].mean() if active.any() else 0.0 # only hits\n", + " mean_total_like_training = mean_bce + mean_mse\n", + "\n", + " # you can print or log these if you want to check:\n", + " # print(mean_bce, mean_mse, mean_total_like_training)\n", + "\n", + " return total, weighted_bce, weighted_mse, best_perm\n", + "\n", + "\n", + "# ─── Analysis Execution ───────────────────────────────────────\n", + "img = X_images[idx, ..., 0]\n", + "gt_lbl = y_labels[idx] # (H,W,K,3)\n", + "pred_lbl = model.predict(img[None], verbose=0)[0] # (H,W,K,3)\n", + "\n", + "# Compute losses\n", + "total_loss, bce, mse, best_perm = compute_analysis_loss(gt_lbl, pred_lbl)\n", + "\n", + "# Create DataFrame\n", + "H, W, K = gt_lbl.shape[:3]\n", + "rows_idx, cols_idx = np.unravel_index(np.arange(H*W), (H, W))\n", + "num_hits = (gt_lbl[..., 0] > 0.5).reshape(-1, K).sum(axis=1)\n", + "\n", + "df_summary = pd.DataFrame({\n", + " \"row\": rows_idx,\n", + " \"col\": cols_idx,\n", + " \"num_hits\": num_hits,\n", + " \"best_perm\": [tuple(p) for p in best_perm], # Store permutation used for MSE\n", + " \"BCE\": bce,\n", + " \"MSE\": mse,\n", + " \"combined\": total_loss\n", + "})\n", + "\n", + "def unpack_slots(selected):\n", + " \"\"\"Unpack slots showing:\n", + " - Natural order for BCE\n", + " - Permuted order for MSE visualization\n", + " \"\"\"\n", + " records = []\n", + " for _, cell in selected.iterrows():\n", + " r, c = int(cell.row), int(cell.col)\n", + " perm = cell.best_perm\n", + " \n", + " # Ground truth (always natural order)\n", + " y_t = gt_lbl[r, c] # (K,3)\n", + " \n", + " # Predictions:\n", + " p_pred = pred_lbl[r, c, :, 0] # Natural order probabilities (K,)\n", + " xy_pred = pred_lbl[r, c, :, 1:] # All coordinates (K,2)\n", + " \n", + " # Apply permutation to coordinates only\n", + " xy_pred_perm = xy_pred[list(perm)] if K > 1 else xy_pred # (K,2)\n", + " \n", + " for k in range(K):\n", + " records.append({\n", + " \"row\": r, \"col\": c, \"slot\": k,\n", + " \"GT_p\": float(y_t[k, 0]),\n", + " \"GT_x\": float(y_t[k, 1]), \n", + " \"GT_y\": float(y_t[k, 2]),\n", + " \"PR_p\": float(p_pred[k]), # Natural order probability\n", + " \"PR_x\": float(xy_pred_perm[k, 0]), # Permuted coordinates\n", + " \"PR_y\": float(xy_pred_perm[k, 1]),\n", + " # \"dist\": np.sqrt((y_t[k,1]-xy_pred_perm[k,0])**2 + (y_t[k,2]-xy_pred_perm[k,1])**2) if y_t[k,0] > 0.5 else np.nan,\n", + " \"cell_BCE\": float(cell.BCE) if k==0 else \"\",\n", + " \"cell_MSE\": float(cell.MSE) if k==0 else \"\",\n", + " \"combined\": float(cell.combined) if k==0 else \"\",\n", + " })\n", + " return pd.DataFrame(records)\n", + "\n", + "# Generate sample tables\n", + "tables = {}\n", + "for hits in (1, 2):\n", + " group = df_summary[df_summary['num_hits']==hits]\n", + " if not group.empty:\n", + " best5 = group.nsmallest(5, 'combined')\n", + " worst5 = group.nlargest(5, 'combined')\n", + " tables[f'hits={hits} BEST'] = unpack_slots(best5)\n", + " tables[f'hits={hits} WORST'] = unpack_slots(worst5)\n", + "\n", + "# Display results\n", + "for title, df in tables.items():\n", + " tools.display_dataframe_to_user(title, df)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "04b12424", + "metadata": {}, + "outputs": [], + "source": [ + "mytrue = np.array([[1,0.625, 0.5],[0,0,0]])\n", + "mypred= np.array([[0.977148,0.515033,0.51065],[0.005078,0,0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "fa6764a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1. , 0.5, 0.5],\n", + " [0. , 0. , 0. ]])" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mytrue" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "dd610acb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[9.76844e-01, 5.15033e-01, 5.10650e-01],\n", + " [2.90000e-04, 0.00000e+00, 0.00000e+00]])" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mypred" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "de6ae703", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_prob2 = tf.keras.losses.binary_crossentropy(mytrue[...,0], mypred[...,0])\n", + "loss_prob2" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "5ea044ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_coords = tf.keras.losses.MeanSquaredError()\n", + "loss_coords2 = loss_coords(mytrue[0][1:], mypred[0][1:])\n", + "loss_coords2" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9e251f88", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def plot_loss_histograms(df, metrics=(\"combined\", \"BCE\", \"MSE\")):\n", + " \"\"\"\n", + " Draw log-scaled histograms for the requested loss metrics.\n", + " Each figure overlays the distributions for 0-hit, 1-hit and 2-hit cells.\n", + "\n", + " Parameters\n", + " ----------\n", + " df : pandas.DataFrame\n", + " must contain columns: num_hits, combined, BCE, MSE\n", + " metrics : iterable[str]\n", + " which columns to plot; default = all three\n", + " \"\"\"\n", + " # pick up the three groups\n", + " groups = {h: df[df.num_hits == h] for h in (0, 1, 2)}\n", + "\n", + " for metric in metrics:\n", + " # skip if metric column missing\n", + " if metric not in df.columns:\n", + " print(f\"⚠ column '{metric}' not found – skipping.\")\n", + " continue\n", + "\n", + " plt.figure(figsize=(6, 4))\n", + " # overlay a histogram for each hit-count that exists\n", + " for h, g in groups.items():\n", + " if g.empty:\n", + " continue\n", + " plt.hist(g[metric],\n", + " bins=np.logspace(-6, 0, 60), # wide range on log-x\n", + " histtype='step', # outline only; default colour-cycle\n", + " label=f\"{h}-hit ({len(g)})\",\n", + " log=True) # log y-axis\n", + "\n", + " plt.xscale(\"log\")\n", + " plt.xlabel(metric)\n", + " plt.ylabel(\"count (log scale)\")\n", + " plt.title(f\"Distribution of {metric} per cell\")\n", + " plt.legend()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# ─── usage ─────────────────────────────────────────────────────\n", + "plot_loss_histograms(df_summary) # uses the dataframe you already built\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "b2b2bd11", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frame 6167 — 100 GT hits, 132 predictions\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
grid_rgrid_cslotpnxnyx_pxy_pxtag
003101.0000000.5000000.62500062.0000001.000000Ground‑truth
103200.8958600.5055240.62813064.0441911.025043Prediction
204101.0000000.6250000.62500083.0000001.000000Ground‑truth
304100.8352380.6116050.58786382.8928430.702902Prediction
4211801.0000000.6250000.500000237.0000004.000000Ground‑truth
533401.0000000.6250000.62500069.0000007.000000Ground‑truth
633400.9109560.6223310.61440468.9786466.915235Prediction
733500.7227050.4981600.62889469.9852817.031148Prediction
8312001.0000000.5000000.500000240.0000006.000000Ground‑truth
9312000.9382280.5102180.505156240.0817416.041245Prediction
1044201.0000000.5000000.50000084.0000008.000000Ground‑truth
1144200.9369620.5057230.50182184.0457868.014565Prediction
1245101.0000000.5000000.500000102.0000008.000000Ground‑truth
1345100.8676690.5104280.511808102.0834288.094465Prediction
1446001.0000000.5000000.625000120.0000009.000000Ground‑truth
1548900.9716010.5575500.503723178.4604038.029785Prediction
16410000.8312400.6158180.609260200.9265408.874081Prediction
17410101.0000000.5000000.625000202.0000009.000000Ground‑truth
18410100.8366180.5020800.615138202.0166408.921102Prediction
1953801.0000000.5000000.62500076.00000011.000000Ground‑truth
2056000.9730540.5055480.507968120.04438210.063745Prediction
2159100.6771960.5161010.628681182.12880611.029444Prediction
2263800.7518760.5211530.52104976.16922312.168391Prediction
2369101.0000000.5000000.500000182.00000012.000000Ground‑truth
2469100.7385030.5096900.498282182.07751611.986254Prediction
2573401.0000000.5000000.50000068.00000014.000000Ground‑truth
2673400.9388100.5436680.50986468.34934614.078915Prediction
2778801.0000000.5000000.500000176.00000014.000000Ground‑truth
2878800.9213080.6136080.503464176.90886414.027709Prediction
29101900.9107530.6171770.50496838.93741920.039742Prediction
30102001.0000000.5000000.50000040.00000020.000000Ground‑truth
31143501.0000000.6250000.62500071.00000029.000000Ground‑truth
32143500.8805160.6215660.61731470.97253228.938514Prediction
33143600.7743510.4975730.62298371.98058628.983866Prediction
341712601.0000000.5000000.500000252.00000034.000000Ground‑truth
351712600.9180310.5617800.511958252.49423834.095665Prediction
3618701.0000000.6250000.50000015.00000036.000000Ground‑truth
3718700.9647640.5881370.49913414.70509335.993070Prediction
38187001.0000000.5000000.625000140.00000037.000000Ground‑truth
39187000.9617680.5086070.620700140.06885536.965603Prediction
40189801.0000000.6250000.625000197.00000037.000000Ground‑truth
41189800.9579780.6201760.617152196.96140536.937220Prediction
42193101.0000000.5000000.62500062.00000039.000000Ground‑truth
43193100.9616970.5096360.58324662.07709038.665967Prediction
4420301.0000000.5000000.6250006.00000041.000000Ground‑truth
45201601.0000000.5000000.50000032.00000040.000000Ground‑truth
46201600.9408680.5052130.56556632.04170740.524528Prediction
47209801.0000000.6250000.625000197.00000041.000000Ground‑truth
48209800.8336230.5768310.608553196.61464940.868424Prediction
4921300.9366590.5065610.5015976.05248442.012773Prediction
502111700.9445340.6257660.501563235.00612542.012505Prediction
512111801.0000000.5000000.625000236.00000043.000000Ground‑truth
522111800.5304210.5047210.513167236.03776642.105335Prediction
53227501.0000000.5000000.625000150.00000045.000000Ground‑truth
54237400.5713180.6290980.511089149.03278446.088712Prediction
55237500.9453330.4985030.511833149.98802346.094660Prediction
56249701.0000000.6250000.625000195.00000049.000000Ground‑truth
57249700.9372220.5851620.612259194.68129648.898075Prediction
58263100.8194320.6139250.61584262.91140252.926736Prediction
59263201.0000000.6250000.62500065.00000053.000000Ground‑truth
60263200.6391380.4966350.62034963.97308352.962789Prediction
61273100.5697060.6284810.50425063.02785054.034001Prediction
62278501.0000000.6250000.625000171.00000055.000000Ground‑truth
63278500.9450340.6184820.615797170.94785554.926376Prediction
6430501.0000000.5000000.50000010.00000060.000000Ground‑truth
6530500.9577320.5077360.55104510.06188860.408360Prediction
66307901.0000000.5000000.625000158.00000061.000000Ground‑truth
67307900.9284200.5041480.615177158.03318260.921418Prediction
68308201.0000000.6250000.500000165.00000060.000000Ground‑truth
69308200.9216040.6163870.570406164.93109660.563246Prediction
70308300.5863920.4990560.586988165.99244960.695904Prediction
71315601.0000000.6250000.625000113.00000063.000000Ground‑truth
72315600.9055170.5977680.606907112.78214262.855257Prediction
73325600.7142010.6147800.497580112.91824163.980638Prediction
743210500.8164010.5991740.540094210.79339364.320751Prediction
753210601.0000000.5000000.625000212.00000065.000000Ground‑truth
763210600.7746090.5049460.567873212.03957064.542984Prediction
77332201.0000000.5000000.50000044.00000066.000000Ground‑truth
78332200.9340960.5065890.50128644.05270966.010289Prediction
79356401.0000000.6250000.500000129.00000070.000000Ground‑truth
80356400.9568470.6149080.593228128.91926370.745824Prediction
81372201.0000000.6250000.50000045.00000074.000000Ground‑truth
82372200.9645620.5738340.50698344.59067574.055865Prediction
83372601.0000000.6250000.50000053.00000074.000000Ground‑truth
84372600.9139660.6222120.55523552.97769374.441883Prediction
85385901.0000000.6250000.625000119.00000077.000000Ground‑truth
86392401.0000000.6250000.50000049.00000078.000000Ground‑truth
87392400.9464430.6154600.50510548.92367878.040841Prediction
88395900.9683430.6169300.561782118.93544078.494255Prediction
89396601.0000000.5000000.625000132.00000079.000000Ground‑truth
90396600.9538880.6254980.619094133.00398278.952753Prediction
91414100.8468650.6176130.50918682.94090182.073490Prediction
92414201.0000000.5000000.50000084.00000082.000000Ground‑truth
93421101.0000000.6250000.50000023.00000084.000000Ground‑truth
94421100.9241860.5591780.50631422.47342484.050511Prediction
954211501.0000000.6250000.500000231.00000084.000000Ground‑truth
964211500.8979270.6137300.503344230.90983984.026756Prediction
97456501.0000000.5000000.625000130.00000091.000000Ground‑truth
98456500.7763600.5132730.607144130.10618190.857156Prediction
99462901.0000000.6250000.62500059.00000093.000000Ground‑truth
100462900.9035890.6143850.59245158.91508092.739612Prediction
101483401.0000000.6250000.62500069.00000097.000000Ground‑truth
102483400.8650790.6252550.61930469.00203796.954433Prediction
103483500.7433960.4996160.61597669.99692996.927811Prediction
104505000.8194400.6149600.618253100.919681100.946024Prediction
105511000.8914400.6049100.55796220.839283102.463693Prediction
106511101.0000000.5000000.50000022.000000102.000000Ground‑truth
107511100.7098670.5003440.56023322.002756102.481860Prediction
108515001.0000000.6250000.500000101.000000102.000000Ground‑truth
109515000.8748570.6105620.508793100.884498102.070340Prediction
110515701.0000000.6250000.625000115.000000103.000000Ground‑truth
111515700.9230850.6213480.617746114.970788102.941967Prediction
112546501.0000000.6250000.500000131.000000108.000000Ground‑truth
113546500.9566880.6172560.503369130.938051108.026953Prediction
114548101.0000000.5000000.625000162.000000109.000000Ground‑truth
115548100.9526230.5149000.621022162.119203108.968177Prediction
116548601.0000000.6250000.625000173.000000109.000000Ground‑truth
117548600.9475640.5626290.598086172.501036108.784692Prediction
118549700.9752470.5099960.529358194.079966108.234861Prediction
119556801.0000000.6250000.625000137.000000111.000000Ground‑truth
120556800.8790570.6210900.614783136.968724110.918265Prediction
121556900.7879270.4975160.624628137.980131110.997023Prediction
122569600.7657480.5065890.626385192.052710113.011078Prediction
123579601.0000000.5000000.500000192.000000114.000000Ground‑truth
124579600.8437980.5039580.494854192.031664113.958830Prediction
125596400.7136640.6101460.628764128.881170119.030114Prediction
1265911800.7640090.5594880.630228236.475902119.041826Prediction
127602501.0000000.6250000.62500051.000000121.000000Ground‑truth
128602500.9346430.6180890.58966050.944715120.717278Prediction
129606401.0000000.6250000.500000129.000000120.000000Ground‑truth
130606400.8307450.6199860.496968128.959888119.975744Prediction
1316011101.0000000.6250000.500000223.000000120.000000Ground‑truth
1326011100.9292350.6187300.505084222.949837120.040668Prediction
1336011801.0000000.5000000.500000236.000000120.000000Ground‑truth
1346011800.8734230.5189980.494566236.151986119.956532Prediction
13561301.0000000.5000000.6250006.000000123.000000Ground‑truth
13661300.8567730.5240490.6324676.192395123.059736Prediction
13762300.7804080.5471780.4911736.377421123.929385Prediction
138626001.0000000.6250000.625000121.000000125.000000Ground‑truth
139626000.9489710.5741210.614643120.592972124.917147Prediction
140637401.0000000.6250000.500000149.000000126.000000Ground‑truth
141637400.8666390.6211010.628358148.968811127.026865Prediction
142641001.0000000.5000000.50000020.000000128.000000Ground‑truth
143641000.9537360.5063380.50402220.050701128.032177Prediction
144644701.0000000.5000000.62500094.000000129.000000Ground‑truth
145644700.9185160.5101690.61584494.081356128.926752Prediction
146647400.7554840.6172580.498967148.938067127.991733Prediction
1476410401.0000000.5000000.625000208.000000129.000000Ground‑truth
1486410400.5344110.5271000.604343208.216803128.834747Prediction
1496511701.0000000.6250000.500000235.000000130.000000Ground‑truth
1506511700.9078680.5897660.505083234.718129130.040665Prediction
151663801.0000000.5000000.62500076.000000133.000000Ground‑truth
152663800.9364780.5071440.59033276.057150132.722658Prediction
153664900.9235660.5896470.62728498.717177133.018275Prediction
154674901.0000000.6250000.50000099.000000134.000000Ground‑truth
155674900.6708710.5443140.51683398.354509134.134666Prediction
156684501.0000000.6250000.62500091.000000137.000000Ground‑truth
157684600.9153870.5092430.61581592.073941136.926521Prediction
158693000.8857970.5891250.49992660.713003137.999409Prediction
1596911601.0000000.5000000.500000232.000000138.000000Ground‑truth
1606911600.9488260.5064090.503248232.051270138.025986Prediction
161703001.0000000.6250000.50000061.000000140.000000Ground‑truth
162711401.0000000.6250000.50000029.000000142.000000Ground‑truth
163711400.8252890.6278540.50870929.022828142.069675Prediction
164711500.8069140.5010820.50828930.008659142.066315Prediction
16572501.0000000.6250000.50000011.000000144.000000Ground‑truth
16672500.9616630.5053490.50555710.042794144.044457Prediction
167725601.0000000.5000000.500000112.000000144.000000Ground‑truth
168725600.9297850.5485780.506202112.388623144.049614Prediction
169731001.0000000.6250000.50000021.000000146.000000Ground‑truth
170731000.9405270.6178680.50456020.942943146.036480Prediction
1717610201.0000000.5000000.500000204.000000152.000000Ground‑truth
1727610200.9111210.4946350.544895203.957081152.359163Prediction
173788501.0000000.6250000.500000171.000000156.000000Ground‑truth
174788500.9276610.5830600.614845170.664482156.918756Prediction
175832701.0000000.6250000.50000055.000000166.000000Ground‑truth
176832700.9427930.5753030.51053554.602427166.084278Prediction
177835301.0000000.5000000.500000106.000000166.000000Ground‑truth
178835300.9522110.5452840.504991106.362270166.039924Prediction
179854201.0000000.6250000.62500085.000000171.000000Ground‑truth
180854200.9123730.6229940.62196784.983956170.975736Prediction
181854300.6386100.5016510.61822786.013204170.945814Prediction
182888001.0000000.6250000.500000161.000000176.000000Ground‑truth
183888000.8897720.6246120.554783160.996896176.438261Prediction
184888100.5290340.5126940.520901162.101549176.167205Prediction
1858912701.0000000.6250000.500000255.000000178.000000Ground‑truth
1868912700.9073700.6010700.506667254.808562178.053337Prediction
187918700.9233420.6270970.623537175.016773182.988297Prediction
1889110801.0000000.6250000.500000217.000000182.000000Ground‑truth
1899110800.9279790.6210940.524581216.968750182.196650Prediction
190922601.0000000.6250000.62500053.000000185.000000Ground‑truth
191922600.8380410.5738840.62347852.591074184.987821Prediction
192928701.0000000.6250000.500000175.000000184.000000Ground‑truth
193928700.5935420.6132820.506884174.906253184.055075Prediction
194932600.8453170.5445420.49670152.356334185.973610Prediction
1959312101.0000000.5000000.500000242.000000186.000000Ground‑truth
1969312100.9327780.5066030.501133242.052822186.009060Prediction
197947401.0000000.5000000.500000148.000000188.000000Ground‑truth
198947400.9233120.5631410.584238148.505130188.673902Prediction
199953700.8479050.6118930.56160074.895143190.492803Prediction
200953801.0000000.5000000.62500076.000000191.000000Ground‑truth
201953800.7978100.5015000.54594876.011998190.367587Prediction
202978600.8239960.5081840.619805172.065471194.958444Prediction
203986800.7306000.6266760.507243137.013408196.057948Prediction
204986901.0000000.5000000.500000138.000000196.000000Ground‑truth
205986900.8697450.5018970.504720138.015177196.037764Prediction
206988601.0000000.5000000.500000172.000000196.000000Ground‑truth
207988600.8352820.5051250.492669172.041003195.941356Prediction
2089810601.0000000.5000000.625000212.000000197.000000Ground‑truth
2099810600.9389150.5564890.549175212.451914196.393399Prediction
210992401.0000000.6250000.50000049.000000198.000000Ground‑truth
211992400.7481620.6038240.51866748.830595198.149337Prediction
21210211001.0000000.5000000.500000220.000000204.000000Ground‑truth
21310211000.9251190.5589220.595748220.471375204.765983Prediction
2141059101.0000000.6250000.500000183.000000210.000000Ground‑truth
2151059100.9654680.6120220.593659182.896175210.749272Prediction
21610910901.0000000.6250000.625000219.000000219.000000Ground‑truth
21711011000.7745430.5094280.607289220.075426220.858315Prediction
2181146000.5065170.6045980.609546120.836784228.876364Prediction
21911410801.0000000.6250000.625000217.000000229.000000Ground‑truth
22011410800.9480050.6186240.615878216.948994228.927024Prediction
2211156001.0000000.6250000.500000121.000000230.000000Ground‑truth
2221156000.9044200.6146490.496483120.917195229.971865Prediction
22312011400.8862010.6108540.614431228.886828240.915450Prediction
22412111501.0000000.5000000.500000230.000000242.000000Ground‑truth
2251225201.0000000.6250000.500000105.000000244.000000Ground‑truth
2261225200.9312960.5985050.560218104.788043244.481741Prediction
2271259600.7623120.6241070.505603192.992855250.044821Prediction
2281259701.0000000.5000000.500000194.000000250.000000Ground‑truth
2291259700.8531450.4992950.508174193.994359250.065396Prediction
2301261201.0000000.5000000.50000024.000000252.000000Ground‑truth
2311261200.9215080.5028680.56295024.022943252.503597Prediction
\n", + "
" + ], + "text/plain": [ + " grid_r grid_c slot p nx ny x_px \\\n", + "0 0 31 0 1.000000 0.500000 0.625000 62.000000 \n", + "1 0 32 0 0.895860 0.505524 0.628130 64.044191 \n", + "2 0 41 0 1.000000 0.625000 0.625000 83.000000 \n", + "3 0 41 0 0.835238 0.611605 0.587863 82.892843 \n", + "4 2 118 0 1.000000 0.625000 0.500000 237.000000 \n", + "5 3 34 0 1.000000 0.625000 0.625000 69.000000 \n", + "6 3 34 0 0.910956 0.622331 0.614404 68.978646 \n", + "7 3 35 0 0.722705 0.498160 0.628894 69.985281 \n", + "8 3 120 0 1.000000 0.500000 0.500000 240.000000 \n", + "9 3 120 0 0.938228 0.510218 0.505156 240.081741 \n", + "10 4 42 0 1.000000 0.500000 0.500000 84.000000 \n", + "11 4 42 0 0.936962 0.505723 0.501821 84.045786 \n", + "12 4 51 0 1.000000 0.500000 0.500000 102.000000 \n", + "13 4 51 0 0.867669 0.510428 0.511808 102.083428 \n", + "14 4 60 0 1.000000 0.500000 0.625000 120.000000 \n", + "15 4 89 0 0.971601 0.557550 0.503723 178.460403 \n", + "16 4 100 0 0.831240 0.615818 0.609260 200.926540 \n", + "17 4 101 0 1.000000 0.500000 0.625000 202.000000 \n", + "18 4 101 0 0.836618 0.502080 0.615138 202.016640 \n", + "19 5 38 0 1.000000 0.500000 0.625000 76.000000 \n", + "20 5 60 0 0.973054 0.505548 0.507968 120.044382 \n", + "21 5 91 0 0.677196 0.516101 0.628681 182.128806 \n", + "22 6 38 0 0.751876 0.521153 0.521049 76.169223 \n", + "23 6 91 0 1.000000 0.500000 0.500000 182.000000 \n", + "24 6 91 0 0.738503 0.509690 0.498282 182.077516 \n", + "25 7 34 0 1.000000 0.500000 0.500000 68.000000 \n", + "26 7 34 0 0.938810 0.543668 0.509864 68.349346 \n", + "27 7 88 0 1.000000 0.500000 0.500000 176.000000 \n", + "28 7 88 0 0.921308 0.613608 0.503464 176.908864 \n", + "29 10 19 0 0.910753 0.617177 0.504968 38.937419 \n", + "30 10 20 0 1.000000 0.500000 0.500000 40.000000 \n", + "31 14 35 0 1.000000 0.625000 0.625000 71.000000 \n", + "32 14 35 0 0.880516 0.621566 0.617314 70.972532 \n", + "33 14 36 0 0.774351 0.497573 0.622983 71.980586 \n", + "34 17 126 0 1.000000 0.500000 0.500000 252.000000 \n", + "35 17 126 0 0.918031 0.561780 0.511958 252.494238 \n", + "36 18 7 0 1.000000 0.625000 0.500000 15.000000 \n", + "37 18 7 0 0.964764 0.588137 0.499134 14.705093 \n", + "38 18 70 0 1.000000 0.500000 0.625000 140.000000 \n", + "39 18 70 0 0.961768 0.508607 0.620700 140.068855 \n", + "40 18 98 0 1.000000 0.625000 0.625000 197.000000 \n", + "41 18 98 0 0.957978 0.620176 0.617152 196.961405 \n", + "42 19 31 0 1.000000 0.500000 0.625000 62.000000 \n", + "43 19 31 0 0.961697 0.509636 0.583246 62.077090 \n", + "44 20 3 0 1.000000 0.500000 0.625000 6.000000 \n", + "45 20 16 0 1.000000 0.500000 0.500000 32.000000 \n", + "46 20 16 0 0.940868 0.505213 0.565566 32.041707 \n", + "47 20 98 0 1.000000 0.625000 0.625000 197.000000 \n", + "48 20 98 0 0.833623 0.576831 0.608553 196.614649 \n", + "49 21 3 0 0.936659 0.506561 0.501597 6.052484 \n", + "50 21 117 0 0.944534 0.625766 0.501563 235.006125 \n", + "51 21 118 0 1.000000 0.500000 0.625000 236.000000 \n", + "52 21 118 0 0.530421 0.504721 0.513167 236.037766 \n", + "53 22 75 0 1.000000 0.500000 0.625000 150.000000 \n", + "54 23 74 0 0.571318 0.629098 0.511089 149.032784 \n", + "55 23 75 0 0.945333 0.498503 0.511833 149.988023 \n", + "56 24 97 0 1.000000 0.625000 0.625000 195.000000 \n", + "57 24 97 0 0.937222 0.585162 0.612259 194.681296 \n", + "58 26 31 0 0.819432 0.613925 0.615842 62.911402 \n", + "59 26 32 0 1.000000 0.625000 0.625000 65.000000 \n", + "60 26 32 0 0.639138 0.496635 0.620349 63.973083 \n", + "61 27 31 0 0.569706 0.628481 0.504250 63.027850 \n", + "62 27 85 0 1.000000 0.625000 0.625000 171.000000 \n", + "63 27 85 0 0.945034 0.618482 0.615797 170.947855 \n", + "64 30 5 0 1.000000 0.500000 0.500000 10.000000 \n", + "65 30 5 0 0.957732 0.507736 0.551045 10.061888 \n", + "66 30 79 0 1.000000 0.500000 0.625000 158.000000 \n", + "67 30 79 0 0.928420 0.504148 0.615177 158.033182 \n", + "68 30 82 0 1.000000 0.625000 0.500000 165.000000 \n", + "69 30 82 0 0.921604 0.616387 0.570406 164.931096 \n", + "70 30 83 0 0.586392 0.499056 0.586988 165.992449 \n", + "71 31 56 0 1.000000 0.625000 0.625000 113.000000 \n", + "72 31 56 0 0.905517 0.597768 0.606907 112.782142 \n", + "73 32 56 0 0.714201 0.614780 0.497580 112.918241 \n", + "74 32 105 0 0.816401 0.599174 0.540094 210.793393 \n", + "75 32 106 0 1.000000 0.500000 0.625000 212.000000 \n", + "76 32 106 0 0.774609 0.504946 0.567873 212.039570 \n", + "77 33 22 0 1.000000 0.500000 0.500000 44.000000 \n", + "78 33 22 0 0.934096 0.506589 0.501286 44.052709 \n", + "79 35 64 0 1.000000 0.625000 0.500000 129.000000 \n", + "80 35 64 0 0.956847 0.614908 0.593228 128.919263 \n", + "81 37 22 0 1.000000 0.625000 0.500000 45.000000 \n", + "82 37 22 0 0.964562 0.573834 0.506983 44.590675 \n", + "83 37 26 0 1.000000 0.625000 0.500000 53.000000 \n", + "84 37 26 0 0.913966 0.622212 0.555235 52.977693 \n", + "85 38 59 0 1.000000 0.625000 0.625000 119.000000 \n", + "86 39 24 0 1.000000 0.625000 0.500000 49.000000 \n", + "87 39 24 0 0.946443 0.615460 0.505105 48.923678 \n", + "88 39 59 0 0.968343 0.616930 0.561782 118.935440 \n", + "89 39 66 0 1.000000 0.500000 0.625000 132.000000 \n", + "90 39 66 0 0.953888 0.625498 0.619094 133.003982 \n", + "91 41 41 0 0.846865 0.617613 0.509186 82.940901 \n", + "92 41 42 0 1.000000 0.500000 0.500000 84.000000 \n", + "93 42 11 0 1.000000 0.625000 0.500000 23.000000 \n", + "94 42 11 0 0.924186 0.559178 0.506314 22.473424 \n", + "95 42 115 0 1.000000 0.625000 0.500000 231.000000 \n", + "96 42 115 0 0.897927 0.613730 0.503344 230.909839 \n", + "97 45 65 0 1.000000 0.500000 0.625000 130.000000 \n", + "98 45 65 0 0.776360 0.513273 0.607144 130.106181 \n", + "99 46 29 0 1.000000 0.625000 0.625000 59.000000 \n", + "100 46 29 0 0.903589 0.614385 0.592451 58.915080 \n", + "101 48 34 0 1.000000 0.625000 0.625000 69.000000 \n", + "102 48 34 0 0.865079 0.625255 0.619304 69.002037 \n", + "103 48 35 0 0.743396 0.499616 0.615976 69.996929 \n", + "104 50 50 0 0.819440 0.614960 0.618253 100.919681 \n", + "105 51 10 0 0.891440 0.604910 0.557962 20.839283 \n", + "106 51 11 0 1.000000 0.500000 0.500000 22.000000 \n", + "107 51 11 0 0.709867 0.500344 0.560233 22.002756 \n", + "108 51 50 0 1.000000 0.625000 0.500000 101.000000 \n", + "109 51 50 0 0.874857 0.610562 0.508793 100.884498 \n", + "110 51 57 0 1.000000 0.625000 0.625000 115.000000 \n", + "111 51 57 0 0.923085 0.621348 0.617746 114.970788 \n", + "112 54 65 0 1.000000 0.625000 0.500000 131.000000 \n", + "113 54 65 0 0.956688 0.617256 0.503369 130.938051 \n", + "114 54 81 0 1.000000 0.500000 0.625000 162.000000 \n", + "115 54 81 0 0.952623 0.514900 0.621022 162.119203 \n", + "116 54 86 0 1.000000 0.625000 0.625000 173.000000 \n", + "117 54 86 0 0.947564 0.562629 0.598086 172.501036 \n", + "118 54 97 0 0.975247 0.509996 0.529358 194.079966 \n", + "119 55 68 0 1.000000 0.625000 0.625000 137.000000 \n", + "120 55 68 0 0.879057 0.621090 0.614783 136.968724 \n", + "121 55 69 0 0.787927 0.497516 0.624628 137.980131 \n", + "122 56 96 0 0.765748 0.506589 0.626385 192.052710 \n", + "123 57 96 0 1.000000 0.500000 0.500000 192.000000 \n", + "124 57 96 0 0.843798 0.503958 0.494854 192.031664 \n", + "125 59 64 0 0.713664 0.610146 0.628764 128.881170 \n", + "126 59 118 0 0.764009 0.559488 0.630228 236.475902 \n", + "127 60 25 0 1.000000 0.625000 0.625000 51.000000 \n", + "128 60 25 0 0.934643 0.618089 0.589660 50.944715 \n", + "129 60 64 0 1.000000 0.625000 0.500000 129.000000 \n", + "130 60 64 0 0.830745 0.619986 0.496968 128.959888 \n", + "131 60 111 0 1.000000 0.625000 0.500000 223.000000 \n", + "132 60 111 0 0.929235 0.618730 0.505084 222.949837 \n", + "133 60 118 0 1.000000 0.500000 0.500000 236.000000 \n", + "134 60 118 0 0.873423 0.518998 0.494566 236.151986 \n", + "135 61 3 0 1.000000 0.500000 0.625000 6.000000 \n", + "136 61 3 0 0.856773 0.524049 0.632467 6.192395 \n", + "137 62 3 0 0.780408 0.547178 0.491173 6.377421 \n", + "138 62 60 0 1.000000 0.625000 0.625000 121.000000 \n", + "139 62 60 0 0.948971 0.574121 0.614643 120.592972 \n", + "140 63 74 0 1.000000 0.625000 0.500000 149.000000 \n", + "141 63 74 0 0.866639 0.621101 0.628358 148.968811 \n", + "142 64 10 0 1.000000 0.500000 0.500000 20.000000 \n", + "143 64 10 0 0.953736 0.506338 0.504022 20.050701 \n", + "144 64 47 0 1.000000 0.500000 0.625000 94.000000 \n", + "145 64 47 0 0.918516 0.510169 0.615844 94.081356 \n", + "146 64 74 0 0.755484 0.617258 0.498967 148.938067 \n", + "147 64 104 0 1.000000 0.500000 0.625000 208.000000 \n", + "148 64 104 0 0.534411 0.527100 0.604343 208.216803 \n", + "149 65 117 0 1.000000 0.625000 0.500000 235.000000 \n", + "150 65 117 0 0.907868 0.589766 0.505083 234.718129 \n", + "151 66 38 0 1.000000 0.500000 0.625000 76.000000 \n", + "152 66 38 0 0.936478 0.507144 0.590332 76.057150 \n", + "153 66 49 0 0.923566 0.589647 0.627284 98.717177 \n", + "154 67 49 0 1.000000 0.625000 0.500000 99.000000 \n", + "155 67 49 0 0.670871 0.544314 0.516833 98.354509 \n", + "156 68 45 0 1.000000 0.625000 0.625000 91.000000 \n", + "157 68 46 0 0.915387 0.509243 0.615815 92.073941 \n", + "158 69 30 0 0.885797 0.589125 0.499926 60.713003 \n", + "159 69 116 0 1.000000 0.500000 0.500000 232.000000 \n", + "160 69 116 0 0.948826 0.506409 0.503248 232.051270 \n", + "161 70 30 0 1.000000 0.625000 0.500000 61.000000 \n", + "162 71 14 0 1.000000 0.625000 0.500000 29.000000 \n", + "163 71 14 0 0.825289 0.627854 0.508709 29.022828 \n", + "164 71 15 0 0.806914 0.501082 0.508289 30.008659 \n", + "165 72 5 0 1.000000 0.625000 0.500000 11.000000 \n", + "166 72 5 0 0.961663 0.505349 0.505557 10.042794 \n", + "167 72 56 0 1.000000 0.500000 0.500000 112.000000 \n", + "168 72 56 0 0.929785 0.548578 0.506202 112.388623 \n", + "169 73 10 0 1.000000 0.625000 0.500000 21.000000 \n", + "170 73 10 0 0.940527 0.617868 0.504560 20.942943 \n", + "171 76 102 0 1.000000 0.500000 0.500000 204.000000 \n", + "172 76 102 0 0.911121 0.494635 0.544895 203.957081 \n", + "173 78 85 0 1.000000 0.625000 0.500000 171.000000 \n", + "174 78 85 0 0.927661 0.583060 0.614845 170.664482 \n", + "175 83 27 0 1.000000 0.625000 0.500000 55.000000 \n", + "176 83 27 0 0.942793 0.575303 0.510535 54.602427 \n", + "177 83 53 0 1.000000 0.500000 0.500000 106.000000 \n", + "178 83 53 0 0.952211 0.545284 0.504991 106.362270 \n", + "179 85 42 0 1.000000 0.625000 0.625000 85.000000 \n", + "180 85 42 0 0.912373 0.622994 0.621967 84.983956 \n", + "181 85 43 0 0.638610 0.501651 0.618227 86.013204 \n", + "182 88 80 0 1.000000 0.625000 0.500000 161.000000 \n", + "183 88 80 0 0.889772 0.624612 0.554783 160.996896 \n", + "184 88 81 0 0.529034 0.512694 0.520901 162.101549 \n", + "185 89 127 0 1.000000 0.625000 0.500000 255.000000 \n", + "186 89 127 0 0.907370 0.601070 0.506667 254.808562 \n", + "187 91 87 0 0.923342 0.627097 0.623537 175.016773 \n", + "188 91 108 0 1.000000 0.625000 0.500000 217.000000 \n", + "189 91 108 0 0.927979 0.621094 0.524581 216.968750 \n", + "190 92 26 0 1.000000 0.625000 0.625000 53.000000 \n", + "191 92 26 0 0.838041 0.573884 0.623478 52.591074 \n", + "192 92 87 0 1.000000 0.625000 0.500000 175.000000 \n", + "193 92 87 0 0.593542 0.613282 0.506884 174.906253 \n", + "194 93 26 0 0.845317 0.544542 0.496701 52.356334 \n", + "195 93 121 0 1.000000 0.500000 0.500000 242.000000 \n", + "196 93 121 0 0.932778 0.506603 0.501133 242.052822 \n", + "197 94 74 0 1.000000 0.500000 0.500000 148.000000 \n", + "198 94 74 0 0.923312 0.563141 0.584238 148.505130 \n", + "199 95 37 0 0.847905 0.611893 0.561600 74.895143 \n", + "200 95 38 0 1.000000 0.500000 0.625000 76.000000 \n", + "201 95 38 0 0.797810 0.501500 0.545948 76.011998 \n", + "202 97 86 0 0.823996 0.508184 0.619805 172.065471 \n", + "203 98 68 0 0.730600 0.626676 0.507243 137.013408 \n", + "204 98 69 0 1.000000 0.500000 0.500000 138.000000 \n", + "205 98 69 0 0.869745 0.501897 0.504720 138.015177 \n", + "206 98 86 0 1.000000 0.500000 0.500000 172.000000 \n", + "207 98 86 0 0.835282 0.505125 0.492669 172.041003 \n", + "208 98 106 0 1.000000 0.500000 0.625000 212.000000 \n", + "209 98 106 0 0.938915 0.556489 0.549175 212.451914 \n", + "210 99 24 0 1.000000 0.625000 0.500000 49.000000 \n", + "211 99 24 0 0.748162 0.603824 0.518667 48.830595 \n", + "212 102 110 0 1.000000 0.500000 0.500000 220.000000 \n", + "213 102 110 0 0.925119 0.558922 0.595748 220.471375 \n", + "214 105 91 0 1.000000 0.625000 0.500000 183.000000 \n", + "215 105 91 0 0.965468 0.612022 0.593659 182.896175 \n", + "216 109 109 0 1.000000 0.625000 0.625000 219.000000 \n", + "217 110 110 0 0.774543 0.509428 0.607289 220.075426 \n", + "218 114 60 0 0.506517 0.604598 0.609546 120.836784 \n", + "219 114 108 0 1.000000 0.625000 0.625000 217.000000 \n", + "220 114 108 0 0.948005 0.618624 0.615878 216.948994 \n", + "221 115 60 0 1.000000 0.625000 0.500000 121.000000 \n", + "222 115 60 0 0.904420 0.614649 0.496483 120.917195 \n", + "223 120 114 0 0.886201 0.610854 0.614431 228.886828 \n", + "224 121 115 0 1.000000 0.500000 0.500000 230.000000 \n", + "225 122 52 0 1.000000 0.625000 0.500000 105.000000 \n", + "226 122 52 0 0.931296 0.598505 0.560218 104.788043 \n", + "227 125 96 0 0.762312 0.624107 0.505603 192.992855 \n", + "228 125 97 0 1.000000 0.500000 0.500000 194.000000 \n", + "229 125 97 0 0.853145 0.499295 0.508174 193.994359 \n", + "230 126 12 0 1.000000 0.500000 0.500000 24.000000 \n", + "231 126 12 0 0.921508 0.502868 0.562950 24.022943 \n", + "\n", + " y_px tag \n", + "0 1.000000 Ground‑truth \n", + "1 1.025043 Prediction \n", + "2 1.000000 Ground‑truth \n", + "3 0.702902 Prediction \n", + "4 4.000000 Ground‑truth \n", + "5 7.000000 Ground‑truth \n", + "6 6.915235 Prediction \n", + "7 7.031148 Prediction \n", + "8 6.000000 Ground‑truth \n", + "9 6.041245 Prediction \n", + "10 8.000000 Ground‑truth \n", + "11 8.014565 Prediction \n", + "12 8.000000 Ground‑truth \n", + "13 8.094465 Prediction \n", + "14 9.000000 Ground‑truth \n", + "15 8.029785 Prediction \n", + "16 8.874081 Prediction \n", + "17 9.000000 Ground‑truth \n", + "18 8.921102 Prediction \n", + "19 11.000000 Ground‑truth \n", + "20 10.063745 Prediction \n", + "21 11.029444 Prediction \n", + "22 12.168391 Prediction \n", + "23 12.000000 Ground‑truth \n", + "24 11.986254 Prediction \n", + "25 14.000000 Ground‑truth \n", + "26 14.078915 Prediction \n", + "27 14.000000 Ground‑truth \n", + "28 14.027709 Prediction \n", + "29 20.039742 Prediction \n", + "30 20.000000 Ground‑truth \n", + "31 29.000000 Ground‑truth \n", + "32 28.938514 Prediction \n", + "33 28.983866 Prediction \n", + "34 34.000000 Ground‑truth \n", + "35 34.095665 Prediction \n", + "36 36.000000 Ground‑truth \n", + "37 35.993070 Prediction \n", + "38 37.000000 Ground‑truth \n", + "39 36.965603 Prediction \n", + "40 37.000000 Ground‑truth \n", + "41 36.937220 Prediction \n", + "42 39.000000 Ground‑truth \n", + "43 38.665967 Prediction \n", + "44 41.000000 Ground‑truth \n", + "45 40.000000 Ground‑truth \n", + "46 40.524528 Prediction \n", + "47 41.000000 Ground‑truth \n", + "48 40.868424 Prediction \n", + "49 42.012773 Prediction \n", + "50 42.012505 Prediction \n", + "51 43.000000 Ground‑truth \n", + "52 42.105335 Prediction \n", + "53 45.000000 Ground‑truth \n", + "54 46.088712 Prediction \n", + "55 46.094660 Prediction \n", + "56 49.000000 Ground‑truth \n", + "57 48.898075 Prediction \n", + "58 52.926736 Prediction \n", + "59 53.000000 Ground‑truth \n", + "60 52.962789 Prediction \n", + "61 54.034001 Prediction \n", + "62 55.000000 Ground‑truth \n", + "63 54.926376 Prediction \n", + "64 60.000000 Ground‑truth \n", + "65 60.408360 Prediction \n", + "66 61.000000 Ground‑truth \n", + "67 60.921418 Prediction \n", + "68 60.000000 Ground‑truth \n", + "69 60.563246 Prediction \n", + "70 60.695904 Prediction \n", + "71 63.000000 Ground‑truth \n", + "72 62.855257 Prediction \n", + "73 63.980638 Prediction \n", + "74 64.320751 Prediction \n", + "75 65.000000 Ground‑truth \n", + "76 64.542984 Prediction \n", + "77 66.000000 Ground‑truth \n", + "78 66.010289 Prediction \n", + "79 70.000000 Ground‑truth \n", + "80 70.745824 Prediction \n", + "81 74.000000 Ground‑truth \n", + "82 74.055865 Prediction \n", + "83 74.000000 Ground‑truth \n", + "84 74.441883 Prediction \n", + "85 77.000000 Ground‑truth \n", + "86 78.000000 Ground‑truth \n", + "87 78.040841 Prediction \n", + "88 78.494255 Prediction \n", + "89 79.000000 Ground‑truth \n", + "90 78.952753 Prediction \n", + "91 82.073490 Prediction \n", + "92 82.000000 Ground‑truth \n", + "93 84.000000 Ground‑truth \n", + "94 84.050511 Prediction \n", + "95 84.000000 Ground‑truth \n", + "96 84.026756 Prediction \n", + "97 91.000000 Ground‑truth \n", + "98 90.857156 Prediction \n", + "99 93.000000 Ground‑truth \n", + "100 92.739612 Prediction \n", + "101 97.000000 Ground‑truth \n", + "102 96.954433 Prediction \n", + "103 96.927811 Prediction \n", + "104 100.946024 Prediction \n", + "105 102.463693 Prediction \n", + "106 102.000000 Ground‑truth \n", + "107 102.481860 Prediction \n", + "108 102.000000 Ground‑truth \n", + "109 102.070340 Prediction \n", + "110 103.000000 Ground‑truth \n", + "111 102.941967 Prediction \n", + "112 108.000000 Ground‑truth \n", + "113 108.026953 Prediction \n", + "114 109.000000 Ground‑truth \n", + "115 108.968177 Prediction \n", + "116 109.000000 Ground‑truth \n", + "117 108.784692 Prediction \n", + "118 108.234861 Prediction \n", + "119 111.000000 Ground‑truth \n", + "120 110.918265 Prediction \n", + "121 110.997023 Prediction \n", + "122 113.011078 Prediction \n", + "123 114.000000 Ground‑truth \n", + "124 113.958830 Prediction \n", + "125 119.030114 Prediction \n", + "126 119.041826 Prediction \n", + "127 121.000000 Ground‑truth \n", + "128 120.717278 Prediction \n", + "129 120.000000 Ground‑truth \n", + "130 119.975744 Prediction \n", + "131 120.000000 Ground‑truth \n", + "132 120.040668 Prediction \n", + "133 120.000000 Ground‑truth \n", + "134 119.956532 Prediction \n", + "135 123.000000 Ground‑truth \n", + "136 123.059736 Prediction \n", + "137 123.929385 Prediction \n", + "138 125.000000 Ground‑truth \n", + "139 124.917147 Prediction \n", + "140 126.000000 Ground‑truth \n", + "141 127.026865 Prediction \n", + "142 128.000000 Ground‑truth \n", + "143 128.032177 Prediction \n", + "144 129.000000 Ground‑truth \n", + "145 128.926752 Prediction \n", + "146 127.991733 Prediction \n", + "147 129.000000 Ground‑truth \n", + "148 128.834747 Prediction \n", + "149 130.000000 Ground‑truth \n", + "150 130.040665 Prediction \n", + "151 133.000000 Ground‑truth \n", + "152 132.722658 Prediction \n", + "153 133.018275 Prediction \n", + "154 134.000000 Ground‑truth \n", + "155 134.134666 Prediction \n", + "156 137.000000 Ground‑truth \n", + "157 136.926521 Prediction \n", + "158 137.999409 Prediction \n", + "159 138.000000 Ground‑truth \n", + "160 138.025986 Prediction \n", + "161 140.000000 Ground‑truth \n", + "162 142.000000 Ground‑truth \n", + "163 142.069675 Prediction \n", + "164 142.066315 Prediction \n", + "165 144.000000 Ground‑truth \n", + "166 144.044457 Prediction \n", + "167 144.000000 Ground‑truth \n", + "168 144.049614 Prediction \n", + "169 146.000000 Ground‑truth \n", + "170 146.036480 Prediction \n", + "171 152.000000 Ground‑truth \n", + "172 152.359163 Prediction \n", + "173 156.000000 Ground‑truth \n", + "174 156.918756 Prediction \n", + "175 166.000000 Ground‑truth \n", + "176 166.084278 Prediction \n", + "177 166.000000 Ground‑truth \n", + "178 166.039924 Prediction \n", + "179 171.000000 Ground‑truth \n", + "180 170.975736 Prediction \n", + "181 170.945814 Prediction \n", + "182 176.000000 Ground‑truth \n", + "183 176.438261 Prediction \n", + "184 176.167205 Prediction \n", + "185 178.000000 Ground‑truth \n", + "186 178.053337 Prediction \n", + "187 182.988297 Prediction \n", + "188 182.000000 Ground‑truth \n", + "189 182.196650 Prediction \n", + "190 185.000000 Ground‑truth \n", + "191 184.987821 Prediction \n", + "192 184.000000 Ground‑truth \n", + "193 184.055075 Prediction \n", + "194 185.973610 Prediction \n", + "195 186.000000 Ground‑truth \n", + "196 186.009060 Prediction \n", + "197 188.000000 Ground‑truth \n", + "198 188.673902 Prediction \n", + "199 190.492803 Prediction \n", + "200 191.000000 Ground‑truth \n", + "201 190.367587 Prediction \n", + "202 194.958444 Prediction \n", + "203 196.057948 Prediction \n", + "204 196.000000 Ground‑truth \n", + "205 196.037764 Prediction \n", + "206 196.000000 Ground‑truth \n", + "207 195.941356 Prediction \n", + "208 197.000000 Ground‑truth \n", + "209 196.393399 Prediction \n", + "210 198.000000 Ground‑truth \n", + "211 198.149337 Prediction \n", + "212 204.000000 Ground‑truth \n", + "213 204.765983 Prediction \n", + "214 210.000000 Ground‑truth \n", + "215 210.749272 Prediction \n", + "216 219.000000 Ground‑truth \n", + "217 220.858315 Prediction \n", + "218 228.876364 Prediction \n", + "219 229.000000 Ground‑truth \n", + "220 228.927024 Prediction \n", + "221 230.000000 Ground‑truth \n", + "222 229.971865 Prediction \n", + "223 240.915450 Prediction \n", + "224 242.000000 Ground‑truth \n", + "225 244.000000 Ground‑truth \n", + "226 244.481741 Prediction \n", + "227 250.044821 Prediction \n", + "228 250.000000 Ground‑truth \n", + "229 250.065396 Prediction \n", + "230 252.000000 Ground‑truth \n", + "231 252.503597 Prediction " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# ─── constants (must match your pipeline) ───────────────────────\n", + "STRIDE = 2\n", + "RF_SIZE = 8\n", + "OFFSET = RF_SIZE // 2 # 4\n", + "K = y_labels.shape[-2] # max_hits\n", + "# ────────────────────────────────────────────────────────────────\n", + "\n", + "def frame_to_df(lbl_tensor, tag, p_thresh=0.0):\n", + " \"\"\"\n", + " lbl_tensor : (GRID,GRID,K,3) [p,nx,ny]\n", + " tag : \"GT\" | \"Pred\" label for output table\n", + " \"\"\"\n", + " \n", + " r, c, k = np.where(lbl_tensor[...,0] >= p_thresh)\n", + "\n", + " \n", + " p = lbl_tensor[r, c, k, 0]\n", + " nx = lbl_tensor[r, c, k, 1]\n", + " ny = lbl_tensor[r, c, k, 2]\n", + "\n", + " \n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + " x_px = x0 + nx*RF_SIZE\n", + " y_px = y0 + ny*RF_SIZE\n", + "\n", + " return pd.DataFrame({\n", + " \"grid_r\": r, \"grid_c\": c, \"slot\": k,\n", + " \"p\": p, \"nx\": nx, \"ny\": ny,\n", + " \"x_px\": x_px, \"y_px\": y_px,\n", + " \"tag\": tag\n", + " })\n", + "\n", + "\n", + "frame_id = idx \n", + "gt_tensor = y_labels[frame_id] \n", + "X_images_to_be_predicted = X_images[frame_id,...,0] \n", + "pred_tensor = model.predict(\n", + " X_images_to_be_predicted[None], verbose=0\n", + " )[0] \n", + "\n", + "df_gt = frame_to_df(gt_tensor, \"Ground‑truth\", p_thresh=0.1)\n", + "df_pred = frame_to_df(pred_tensor,\"Prediction\", p_thresh=0.5)\n", + "\n", + "df_frame = pd.concat([df_gt, df_pred]).sort_values(\n", + " [\"grid_r\",\"grid_c\",\"slot\",\"tag\"]\n", + " ).reset_index(drop=True)\n", + "import pandas as pd\n", + "\n", + "\n", + "pd.set_option(\"display.max_rows\", None) \n", + "pd.set_option(\"display.max_columns\", None)\n", + "pd.set_option(\"display.width\", 0) \n", + "\n", + "\n", + "# inspect\n", + "print(f\"Frame {frame_id} — {len(df_gt)} GT hits, {len(df_pred)} predictions\")\n", + "display(df_frame) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c97c5e7a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ObjectDetection2", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ComputerVision_OD_Electron_Counting/Receptive_Field_noProb_Analysis.ipynb b/ComputerVision_OD_Electron_Counting/Receptive_Field_noProb_Analysis.ipynb new file mode 100644 index 0000000..b51ebcf --- /dev/null +++ b/ComputerVision_OD_Electron_Counting/Receptive_Field_noProb_Analysis.ipynb @@ -0,0 +1,1363 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6b5a6fcd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-14 16:49:47.821323: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-05-14 16:49:47.838561: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1747255787.852295 3382202 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1747255787.856429 3382202 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1747255787.869228 3382202 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747255787.869241 3382202 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747255787.869243 3382202 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747255787.869245 3382202 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2025-05-14 16:49:47.875462: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:1',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I0000 00:00:1747255790.045944 3382202 gpu_device.cc:2019] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79192 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" # Only GPUs 6 and 7 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:1\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "534e7c3e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "05c9821e", + "metadata": {}, + "outputs": [], + "source": [ + "import h5py, numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ─── geometry constants ─────────────────────────────────────────\n", + "IMAGE_SIZE = 256\n", + "GRID = 128\n", + "STRIDE = 2\n", + "RF_SIZE = 8\n", + "OFFSET = RF_SIZE // 2 # 4\n", + "MAX_HITS = 2\n", + "# ────────────────────────────────────────────────────────────────\n", + "\n", + "def build_label(hit_array: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " hit_array: (M,3) rows = [id, x_px, y_px] in 64×64 coords\n", + " returns : (32,32,MAX_HITS,3) with slots [p, nx, ny]\n", + " \"\"\"\n", + " lbl = np.zeros((GRID, GRID, MAX_HITS, 3), dtype=np.float32)\n", + " slot_idx = np.zeros((GRID, GRID), dtype=np.int8)\n", + "\n", + " for _i, x_px, y_px in hit_array:\n", + " # 1) which output cell\n", + " c = int(x_px // STRIDE)\n", + " r = int(y_px // STRIDE)\n", + " if not (0 <= r < GRID and 0 <= c < GRID):\n", + " continue\n", + "\n", + " k = slot_idx[r, c]\n", + " if k >= MAX_HITS:\n", + " continue\n", + "\n", + " # 2) top‐left of this RF in input space\n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + "\n", + " # 3) local normalised coords\n", + " nx = (x_px - x0) / RF_SIZE\n", + " ny = (y_px - y0) / RF_SIZE\n", + " # nx = np.clip(nx, 0.0, 1)\n", + " # ny = np.clip(ny, 0.0, 1)\n", + "\n", + " # 4) write slot\n", + " lbl[r, c, k, 0] = 1.0\n", + " lbl[r, c, k, 1] = nx\n", + " lbl[r, c, k, 2] = ny\n", + " slot_idx[r, c] += 1\n", + "\n", + " return lbl\n", + "\n", + "\n", + "def load_dataset(h5_path: str, max_samples: int = None):\n", + " \"\"\"Returns X:(N,64,64,1), y:(N,32,32,MAX_HITS,3)\"\"\"\n", + " with h5py.File(h5_path, \"r\") as f:\n", + " imgs = np.asarray(f[\"images\"][:max_samples], np.float32)\n", + " centers = np.asarray(f[\"centers_training\"][:max_samples]) # (N,M,3)\n", + "\n", + " # normalize + add channel\n", + " X = imgs / (imgs.max() + 1e-7)\n", + " X = X[..., None] # (N,64,64,1)\n", + "\n", + " # build per‐frame label\n", + " y = np.stack([build_label(hits) for hits in centers], axis=0)\n", + " # y.shape == (N,32,32,MAX_HITS,3)\n", + "\n", + " return X, y\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c4d5037e", + "metadata": {}, + "outputs": [], + "source": [ + "h5_file = \"/home/da886/ComputerVision_OD_Electron_Counting/Images_and_Labels/50KFixed_100_256by256_RandomindexNoNoise.h5\"\n", + "X_images,y_labels = load_dataset(h5_file, max_samples=10000) " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c0c76472", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: (9500, 256, 256, 1) (9500, 128, 128, 2, 3)\n", + " Val : (500, 256, 256, 1) (500, 128, 128, 2, 3)\n" + ] + } + ], + "source": [ + "X_train, X_val, y_train, y_val = train_test_split(\n", + " X_images, y_labels,\n", + " test_size=0.05,\n", + " random_state=42,\n", + " shuffle=True\n", + ")\n", + "\n", + "print(\"Train:\", X_train.shape, y_train.shape)\n", + "print(\" Val :\", X_val.shape, y_val.shape)\n", + "\n", + "# 3) Build tf.data pipelines\n", + "batch_size = 64\n", + "\n", + "train_ds = (\n", + " tf.data.Dataset\n", + " .from_tensor_slices((X_train, y_train))\n", + " .shuffle(buffer_size=len(X_train), seed=42)\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE)\n", + ")\n", + "\n", + "val_ds = (\n", + " tf.data.Dataset\n", + " .from_tensor_slices((X_val, y_val))\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5589aecd", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def gating_spatial(tensor):\n", + " raw_p = tensor[..., 0] \n", + " xy = tensor[..., 1:3] \n", + " p = tf.sigmoid(raw_p)[..., None] \n", + " gate = tf.cast(p > 0.5, tf.float32)\n", + " xy_g = xy * gate\n", + " \n", + " return tf.concat([p, xy_g], axis=-1)\n", + "\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "\n", + "class RF8Detector(tf.keras.Model):\n", + " def __init__(self, input_shape=(256,256,1), max_hits=2):\n", + " super().__init__()\n", + " # Define layers with explicit input shapes\n", + " self.conv_block = tf.keras.Sequential([\n", + " layers.Conv2D(32, 3, padding='same', activation='relu', input_shape=input_shape),\n", + " layers.MaxPooling2D(2, padding='same'),\n", + " layers.Conv2D(16, 3, padding='same', activation='relu')\n", + " ])\n", + " self.output_block = tf.keras.Sequential([\n", + " layers.Conv2D(max_hits*3, 1, padding='same'),\n", + " layers.Reshape((128,128,max_hits,3)),\n", + " layers.Lambda(gating_spatial)\n", + " ])\n", + " \n", + " # Force model build\n", + " self.build(input_shape=(None,) + input_shape)\n", + " \n", + " def call(self, inputs):\n", + " x = self.conv_block(inputs)\n", + " return self.output_block(x)\n", + " \n", + " @tf.function # Add this decorator\n", + " def train_step(self, data):\n", + " x, y_true = data\n", + " \n", + " with tf.GradientTape() as tape:\n", + " y_pred = self(x, training=True)\n", + " total_loss, bce, mse = self.compute_loss(y_true, y_pred)\n", + " \n", + " grads = tape.gradient(total_loss, self.trainable_variables)\n", + " self.optimizer.apply_gradients(zip(grads, self.trainable_variables))\n", + " \n", + " return {'loss': total_loss, 'bce': bce, 'mse': mse}\n", + " \n", + " @tf.function # Add this decorator\n", + " def test_step(self, data):\n", + " x, y_true = data\n", + " y_pred = self(x, training=False)\n", + " total_loss, bce, mse = self.compute_loss(y_true, y_pred)\n", + " return {'val_loss': total_loss, 'val_bce': bce, 'val_mse': mse}\n", + " \n", + " def compute_loss(self, y_true, y_pred):\n", + " # Your existing masked_bce_mse_loss logic here\n", + " # Ensure it only uses TensorFlow operations\n", + " p_true = y_true[..., 0]\n", + " xy_true = y_true[..., 1:]\n", + " p_pred = y_pred[..., 0]\n", + " xy_pred = y_pred[..., 1:]\n", + "\n", + " # BCE calculation\n", + " bce = tf.reduce_mean(\n", + " tf.keras.losses.binary_crossentropy(p_true, p_pred)\n", + " )\n", + "\n", + " # Masked MSE calculation\n", + " mask = tf.cast(p_true > 0, tf.float32)[..., tf.newaxis]\n", + " mse = tf.reduce_sum(tf.square(xy_true - xy_pred) * mask) / (tf.reduce_sum(mask) + 1e-6)\n", + "\n", + " return bce + mse, bce, mse # total_loss, bce, mse\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef082776", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" + ] + } + ], + "source": [ + "# model.save(\"/home/da886/ComputerVision_OD_Electron_Counting/Trained_Weights/RF_NoPermutation_2hits.h5\")\n", + "loaded_model = tf.keras.models.load_model(\"/home/da886/ComputerVision_OD_Electron_Counting/Trained_Weights/RF_NoPermutation_2hits.h5\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f31d4a03", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3382202/699240965.py:25: UserWarning: You passed both c and facecolor/facecolors for the markers. c has precedence over facecolor/facecolors. This behavior may change in the future.\n", + " plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# idx = np.random.randint(len(X_images))\n", + "idx =9372\n", + "img = X_images[idx,...,0]\n", + "gt_lbl = y_labels[idx]\n", + "pred_lbl = model.predict(img[None],verbose=0)[0]\n", + "\n", + "\n", + "def unpack(lbl_tensor, threshold=0.5):\n", + " \n", + " r,c,k = np.where(lbl_tensor[...,0] > threshold)\n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + " x = x0 + lbl_tensor[r,c,k,1]*RF_SIZE\n", + " y = y0 + lbl_tensor[r,c,k,2]*RF_SIZE\n", + " return x, y\n", + "\n", + "x_gt, y_gt = unpack(gt_lbl, threshold=0)\n", + "x_pr, y_pr = unpack(pred_lbl, threshold=0.5)\n", + "\n", + "plt.figure(figsize=(12,12))\n", + "plt.imshow(img,cmap='gray', origin=\"upper\")\n", + "plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "plt.scatter(x_gt, y_gt, c=\"red\", marker=\"x\", s=10, label=\"GT\")\n", + "# plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "plt.title(f\"Frame {idx}\")\n", + "plt.legend(loc=\"lower right\")\n", + "# plt.xlim(0,63); plt.ylim(63,0); plt.show()\n", + "plt.xlim(0,255); plt.ylim(255,0); plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "f7887d00", + "metadata": {}, + "source": [ + "Using No Permutation for loss" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15c46674", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=1 SAMPLE\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import ace_tools_open as tools\n", + "import tensorflow as tf\n", + "\n", + "# ─── Hyperparameters ──────────────────────────────────────────\n", + "eps = 1e-6\n", + "λ_xy = 1.0 # weight on the MSE term\n", + "# ──────────────────────────────────────────────────────────────\n", + "\n", + "def compute_loss(y_true, y_pred):\n", + " \"\"\"Exact same implementation as in your training\"\"\"\n", + " p_true = y_true[..., 0]\n", + " xy_true = y_true[..., 1:]\n", + " p_pred = y_pred[..., 0]\n", + " xy_pred = y_pred[..., 1:]\n", + "\n", + " # BCE calculation (mean over all slots)\n", + " bce = tf.reduce_mean(\n", + " tf.keras.losses.binary_crossentropy(p_true, p_pred)\n", + " )\n", + "\n", + " # Masked MSE calculation\n", + " mask = tf.cast(p_true > 0, tf.float32)[..., tf.newaxis] # (..., K, 1)\n", + " squared_error = tf.square(xy_true - xy_pred) # (..., K, 2)\n", + " masked_se = squared_error * mask # (..., K, 2)\n", + " \n", + " # Sum over coordinates and slots, normalize by active slots\n", + " mse = tf.reduce_sum(masked_se) / (tf.reduce_sum(mask) + eps)\n", + " \n", + " return bce + mse, bce, mse # total_loss, bce, mse\n", + "\n", + "# Current frame analysis\n", + "img = X_images[idx, ..., 0]\n", + "gt_lbl = y_labels[idx] # (H,W,K,3)\n", + "pred_lbl = model.predict(img[None], verbose=0)[0] # (H,W,K,3)\n", + "\n", + "H, W = 128, 128\n", + "K = 2\n", + "\n", + "# Compute loss for each cell\n", + "total_loss, bce, mse = compute_loss(\n", + " tf.convert_to_tensor(gt_lbl[np.newaxis], dtype=tf.float32),\n", + " tf.convert_to_tensor(pred_lbl[np.newaxis], dtype=tf.float32)\n", + ")\n", + "\n", + "# Create per-cell metrics\n", + "rows_idx, cols_idx = np.unravel_index(np.arange(H*W), (H, W))\n", + "p_t = gt_lbl[..., 0].reshape(-1, K) # (H*W, K)\n", + "num_hits = (p_t > 0.5).sum(axis=1)\n", + "\n", + "\n", + "df_summary = pd.DataFrame({\n", + " \"row\": rows_idx,\n", + " \"col\": cols_idx,\n", + " \"num_hits\": num_hits,\n", + " # \"best_perm\": [tuple(p) for p in best_perm], # Store permutation used for MSE\n", + " \"BCE\": bce,\n", + " \"MSE\": mse,\n", + " \"combined\": total_loss\n", + "})\n", + "\n", + "def unpack_slots(selected):\n", + " \"\"\"Unpack slot details for selected cells\"\"\"\n", + " records = []\n", + " for _, cell in selected.iterrows():\n", + " r, c = int(cell.row), int(cell.col)\n", + " y_t = gt_lbl[r, c] # (K,3)\n", + " y_p = pred_lbl[r, c] # (K,3)\n", + " \n", + " for k in range(K):\n", + " records.append({\n", + " \"row\": r, \"col\": c, \"slot\": k,\n", + " \"GT_p\": float(y_t[k, 0]),\n", + " \"GT_x\": float(y_t[k, 1]), \"GT_y\": float(y_t[k, 2]),\n", + " \"PR_p\": float(y_p[k, 0]),\n", + " \"PR_x\": float(y_p[k, 1]), \"PR_y\": float(y_p[k, 2]),\n", + " \"cell_BCE\": float(cell.BCE) if k == 0 else \"\",\n", + " \"cell_MSE\": float(cell.MSE) if k == 0 else \"\",\n", + " \"combined\": float(cell.combined) if k == 0 else \"\",\n", + " })\n", + " return pd.DataFrame(records)\n", + "\n", + "# Build tables for hit=1 and hit=2\n", + "tables = {}\n", + "for hits in (1, 2):\n", + " group = df_summary[df_summary['num_hits'] == hits]\n", + " if not group.empty:\n", + " # Since all cells have same loss, just take first 5 of each\n", + " sample = group.head(10)\n", + " tables[f'hits={hits} SAMPLE'] = unpack_slots(sample)\n", + "\n", + "# Display results\n", + "for title, df in tables.items():\n", + " tools.display_dataframe_to_user(title, df)" + ] + }, + { + "cell_type": "markdown", + "id": "e28ff377", + "metadata": {}, + "source": [ + "Manual Computation" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "367c60f2", + "metadata": {}, + "outputs": [], + "source": [ + "mytrue_coords = np.array([[0.625, 0.5],[0,0]])\n", + "mypred_coords = np.array([[0.000000, 0.000000],[0.621302, 0.509042]])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "bb3f0ec7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.625, 0.625],\n", + " [0. , 0. ]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mytrue_coords" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "42b76663", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.32144123\n" + ] + } + ], + "source": [ + "mse = tf.keras.losses.MeanSquaredError()\n", + "loss2 = mse(mytrue_coords, mypred_coords)\n", + "print(loss2.numpy())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "b09cfe59", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_coords = tf.reduce_mean(tf.square(mytrue_coords - mypred_coords))\n", + "loss_coords" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "c82eadb2", + "metadata": {}, + "outputs": [], + "source": [ + "mytrue_prob = np.array([[1],[0]])\n", + "mypred_prob = np.array([[0.347953],[0.000155]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f82d8ed0", + "metadata": {}, + "outputs": [], + "source": [ + "mytrue_prob " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "4fff6ae9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_prob = tf.keras.losses.binary_crossentropy(mytrue_prob, mypred_prob)\n", + "# loss_prob = tf.reduce_mean(loss_prob)\n", + "loss_prob" + ] + }, + { + "cell_type": "markdown", + "id": "75acff82", + "metadata": {}, + "source": [ + "Using Permutation for Loss (MSE permed,BCE no perm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36848ab5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=1 BEST\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-14 17:23:40.903339: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=1 WORST\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import ace_tools_open as tools\n", + "import tensorflow as tf\n", + "from itertools import permutations\n", + "\n", + "# ─── Hyperparameters ──────────────────────────────────────────\n", + "eps = 1e-6\n", + "λ_xy = 1.0 # weight on the MSE term\n", + "# ──────────────────────────────────────────────────────────────\n", + "\n", + "def compute_analysis_loss(y_true, y_pred):\n", + " \"\"\"Analysis function with:\n", + " - Natural BCE (no permutation)\n", + " - Permutation-optimized MSE\n", + " \"\"\"\n", + " p_true = y_true[..., 0] # (H,W,K)\n", + " xy_true = y_true[..., 1:] # (H,W,K,2)\n", + " p_pred = y_pred[..., 0] # (H,W,K)\n", + " xy_pred = y_pred[..., 1:] # (H,W,K,2)\n", + " \n", + " H, W, K = p_true.shape\n", + " PERMS = list(permutations(range(K)))\n", + " \n", + " # Flatten spatial dimensions\n", + " p_t = p_true.reshape(-1, K) # (N,K)\n", + " xy_t = xy_true.reshape(-1, K, 2) # (N,K,2)\n", + " p_p = p_pred.reshape(-1, K) # (N,K)\n", + " xy_p = xy_pred.reshape(-1, K, 2) # (N,K,2)\n", + " N = p_t.shape[0]\n", + " \n", + " # 1. Compute NATURAL BCE (no permutation)\n", + " bce = tf.keras.losses.binary_crossentropy(p_t, p_p).numpy() # (N,)\n", + " \n", + " # 2. Find BEST PERMUTATION for MSE only\n", + " best_mse = np.full(N, np.inf)\n", + " best_perm = np.zeros((N, K), dtype=int)\n", + " \n", + " for perm in PERMS:\n", + " # Apply permutation only to coordinates\n", + " xy_perm = xy_p[:, perm, :] # (N,K,2)\n", + " \n", + " # Masked MSE calculation\n", + " mask = (p_t > 0.5).astype(np.float32)[..., np.newaxis] # (N,K,1)\n", + " se = np.sum((xy_t - xy_perm)**2, axis=2) # (N,K)\n", + " mse = np.sum(se * mask.squeeze(), axis=1) / (np.sum(mask, axis=(1,2)) + eps) # (N,)\n", + " \n", + " # Update best permutation\n", + " better = mse < best_mse\n", + " best_mse[better] = mse[better]\n", + " best_perm[better] = perm\n", + " \n", + " # 3. Compute final loss\n", + " total_loss = bce + λ_xy * best_mse\n", + " \n", + " return total_loss, bce, best_mse, best_perm\n", + "\n", + "# ─── Analysis Execution ───────────────────────────────────────\n", + "img = X_images[idx, ..., 0]\n", + "gt_lbl = y_labels[idx] # (H,W,K,3)\n", + "pred_lbl = model.predict(img[None], verbose=0)[0] # (H,W,K,3)\n", + "\n", + "# Compute losses\n", + "total_loss, bce, mse, best_perm = compute_analysis_loss(gt_lbl, pred_lbl)\n", + "\n", + "# Create DataFrame\n", + "H, W, K = gt_lbl.shape[:3]\n", + "rows_idx, cols_idx = np.unravel_index(np.arange(H*W), (H, W))\n", + "num_hits = (gt_lbl[..., 0] > 0.5).reshape(-1, K).sum(axis=1)\n", + "\n", + "df_summary = pd.DataFrame({\n", + " \"row\": rows_idx,\n", + " \"col\": cols_idx,\n", + " \"num_hits\": num_hits,\n", + " \"best_perm\": [tuple(p) for p in best_perm], # Store permutation used for MSE\n", + " \"BCE\": bce,\n", + " \"MSE\": mse,\n", + " \"combined\": total_loss\n", + "})\n", + "\n", + "def unpack_slots(selected):\n", + " \"\"\"Unpack slots showing:\n", + " - Natural order for BCE\n", + " - Permuted order for MSE visualization\n", + " \"\"\"\n", + " records = []\n", + " for _, cell in selected.iterrows():\n", + " r, c = int(cell.row), int(cell.col)\n", + " perm = cell.best_perm\n", + " \n", + " # Ground truth (always natural order)\n", + " y_t = gt_lbl[r, c] # (K,3)\n", + " \n", + " # Predictions:\n", + " p_pred = pred_lbl[r, c, :, 0] # Natural order probabilities (K,)\n", + " xy_pred = pred_lbl[r, c, :, 1:] # All coordinates (K,2)\n", + " \n", + " # Apply permutation to coordinates only\n", + " xy_pred_perm = xy_pred[list(perm)] if K > 1 else xy_pred # (K,2)\n", + " \n", + " for k in range(K):\n", + " records.append({\n", + " \"row\": r, \"col\": c, \"slot\": k,\n", + " \"GT_p\": float(y_t[k, 0]),\n", + " \"GT_x\": float(y_t[k, 1]), \n", + " \"GT_y\": float(y_t[k, 2]),\n", + " \"PR_p\": float(p_pred[k]), # Natural order probability\n", + " \"PR_x\": float(xy_pred_perm[k, 0]), # Permuted coordinates\n", + " \"PR_y\": float(xy_pred_perm[k, 1]),\n", + " # \"dist\": np.sqrt((y_t[k,1]-xy_pred_perm[k,0])**2 + (y_t[k,2]-xy_pred_perm[k,1])**2) if y_t[k,0] > 0.5 else np.nan,\n", + " \"cell_BCE\": float(cell.BCE) if k==0 else \"\",\n", + " \"cell_MSE\": float(cell.MSE) if k==0 else \"\",\n", + " \"combined\": float(cell.combined) if k==0 else \"\",\n", + " })\n", + " return pd.DataFrame(records)\n", + "\n", + "# Generate sample tables\n", + "tables = {}\n", + "for hits in (1, 2):\n", + " group = df_summary[df_summary['num_hits']==hits]\n", + " if not group.empty:\n", + " best5 = group.nsmallest(5, 'combined')\n", + " worst5 = group.nlargest(5, 'combined')\n", + " tables[f'hits={hits} BEST'] = unpack_slots(best5)\n", + " tables[f'hits={hits} WORST'] = unpack_slots(worst5)\n", + "\n", + "# Display results\n", + "for title, df in tables.items():\n", + " tools.display_dataframe_to_user(title, df)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "04b12424", + "metadata": {}, + "outputs": [], + "source": [ + "mytrue = np.array([[1,0.625, 0.5],[0,0,0]])\n", + "mypred= np.array([[0.001559,0,0],[0.938486,0.618786,0.551404]])" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "fa6764a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1. , 0.625, 0.625],\n", + " [0. , 0. , 0. ]])" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mytrue" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "4a0eb669", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 0.])" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mytrue[...,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "dd610acb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3.548471e-05, 0.000000e+00, 0.000000e+00],\n", + " [7.517793e-08, 0.000000e+00, 0.000000e+00]])" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mypred" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "de6ae703", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_prob2 = tf.keras.losses.binary_crossentropy(mytrue[...,0], mypred[...,0])\n", + "loss_prob2" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "5ea044ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_coords = tf.keras.losses.MeanSquaredError()\n", + "loss_coords2 = loss_coords(mytrue[...,1:], mypred[...,1:])\n", + "loss_coords2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2b2bd11", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c97c5e7a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ObjectDetection2", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ComputerVision_OD_Electron_Counting/Trained_Weights/RF_NoPermutation_2hits.h5 b/ComputerVision_OD_Electron_Counting/Trained_Weights/RF_NoPermutation_2hits.h5 new file mode 100644 index 0000000..4fd85a3 Binary files /dev/null and b/ComputerVision_OD_Electron_Counting/Trained_Weights/RF_NoPermutation_2hits.h5 differ diff --git a/ComputerVision_OD_Electron_Counting/Training.ipynb b/ComputerVision_OD_Electron_Counting/Training.ipynb new file mode 100644 index 0000000..5e19db4 --- /dev/null +++ b/ComputerVision_OD_Electron_Counting/Training.ipynb @@ -0,0 +1,610 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "gpus = tf.config.list_physical_devices('GPU')\n", + "if gpus:\n", + " try:\n", + " for gpu in gpus:\n", + " tf.config.experimental.set_memory_growth(gpus[0], True)\n", + " except RuntimeError as e:\n", + " print(e)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, pad_value=(-1, -1)):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.pad_value = pad_value\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " # Assuming each hit is structured as (id, x, y)\n", + " _, x, y = hit \n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " # Calculate hit coordinates relative to the tile\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self, use_global_max=True):\n", + " \"\"\"\n", + " Returns: \n", + " - tiled_images of shape (num_images, num_tiles, tile_size, tile_size)\n", + " - tiled_centers of shape (num_images, num_tiles, global_max_hits, 2)\n", + " \n", + " If use_global_max is True, the global maximum hit count across all images is computed and used\n", + " for padding/truncating hits in each tile.\n", + " \"\"\"\n", + " tiled_images = []\n", + " tiled_centers = []\n", + " \n", + " # First pass: determine the global maximum number of hits per tile\n", + " global_max_hits = 0\n", + " if use_global_max:\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " _, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " max_hits_in_image = max(len(hit_list) for hit_list in hits_per_tile.values())\n", + " global_max_hits = max(global_max_hits, max_hits_in_image)\n", + " else:\n", + " # Alternatively, you could compute per image max if needed.\n", + " global_max_hits = None\n", + " \n", + " # Second pass: process each image using the global maximum hit count\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " # Use the global maximum if set; otherwise, compute max for the current image.\n", + " if global_max_hits is not None:\n", + " max_hits = global_max_hits\n", + " else:\n", + " max_hits = max(len(hit_list) for hit_list in hits_per_tile.values())\n", + "\n", + " # Pad (or truncate) each tile's hit list to exactly max_hits entries.\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:max_hits] + [self.pad_value] * (max_hits - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " \"\"\"\n", + " Normalizes image pixels into [0, 1] and converts hit coordinates to a tuple (presence, normalized_x, normalized_y)\n", + " where presence is 1 if a hit is present (determined by the coordinate being non-zero) and 0 otherwise.\n", + " \"\"\"\n", + " tiled_images, tiled_centers = self.process_data(use_global_max=True)\n", + " normalized_images = tiled_images / np.max(tiled_images) # Normalize images into [0,1]\n", + "\n", + " presence_coords = []\n", + " for image_hits in tiled_centers:\n", + " new_image_hits = []\n", + " for tile_hits in image_hits:\n", + " tile_hit_info = []\n", + " for (x, y) in tile_hits:\n", + " # Use pad_value to indicate absence; here we check if the hit is the pad value (e.g., (-1,-1))\n", + " if (x, y) == self.pad_value:\n", + " p = 0.0\n", + " else:\n", + " p = 1.0\n", + " # Normalize the x,y coordinates by the tile_size\n", + " nx = x / self.tile_size\n", + " ny = y / self.tile_size\n", + " tile_hit_info.append((p, nx, ny))\n", + " new_image_hits.append(tile_hit_info)\n", + " presence_coords.append(new_image_hits)\n", + "\n", + " return normalized_images, np.array(presence_coords)\n", + " \n", + "def create_datasets(data_loader, train_size=0.95, batch_size=1024):\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + " # Split into train/val at the *image* level\n", + " train_imgs, val_imgs, train_ctrs, val_ctrs = train_test_split(\n", + " normalized_images, normalized_centers,\n", + " train_size=train_size,\n", + " random_state=42\n", + " )\n", + " # Each image has shape (num_tiles, 8, 8)\n", + " # Each label has shape (num_tiles, global_max_hits, 3)\n", + "\n", + " # Flatten tiles => each tile is an 8×8 patch\n", + " train_imgs_flat = train_imgs.reshape(-1, 16, 16, 1)\n", + " val_imgs_flat = val_imgs.reshape(-1, 16, 16, 1)\n", + "\n", + " # Determine dynamic max_hits from the shape of the normalized labels.\n", + " max_hits = train_ctrs.shape[2] # or normalized_centers.shape[2]\n", + "\n", + " # Flatten labels => each tile now has shape (global_max_hits, 3)\n", + " train_ctrs_flat = train_ctrs.reshape(-1, max_hits, 3)\n", + " val_ctrs_flat = val_ctrs.reshape(-1, max_hits, 3)\n", + "\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_imgs_flat, train_ctrs_flat))\n", + " train_dataset = train_dataset.shuffle(buffer_size=512, reshuffle_each_iteration=True)\n", + " train_dataset = train_dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n", + "\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_imgs_flat, val_ctrs_flat))\n", + " val_dataset = val_dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n", + "\n", + " return train_dataset, val_dataset, train_imgs, val_imgs, train_ctrs, val_ctrs\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "file_path = '/home/da886/ComputerVision_OD_Electron_Counting/Images_and_Labels/20KFixed_100_256by256_RandomindexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=16, pad_value=(-1, -1))\n", + "images, centers = data_loader.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "# Create datasets\n", + "train_dataset, val_dataset,train_imgs,val_imgs,train_ctrs,val_ctrs = create_datasets(data_loader,train_size=0.95,batch_size=512)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "# --- Helper function to display a tile with the global max hits ---\n", + "def show_tile_with_global_max(data_loader):\n", + " \"\"\"\n", + " Loads the normalized data and displays one tile that contains the maximum\n", + " number of valid hits (i.e. where the presence value is 1) across the dataset.\n", + " \"\"\"\n", + " # Retrieve normalized images and centers.\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " # normalized_centers shape: (num_images, num_tiles, global_max_hits, 3)\n", + " # Here, the first channel (index 0) is the presence flag.\n", + " \n", + " # Compute the number of valid hits per tile.\n", + " # This gives an array of shape (num_images, num_tiles)\n", + " presence_counts = np.sum(normalized_centers[..., 0] > 0, axis=-1)\n", + " \n", + " # Find the maximum number of valid hits observed in any tile.\n", + " global_presence_max = int(np.max(presence_counts))\n", + " print(\"Global maximum valid hits per tile:\", global_presence_max)\n", + " \n", + " # Find indices (image, tile) where this maximum occurs.\n", + " indices = np.where(presence_counts == global_presence_max)\n", + " \n", + " if len(indices[0]) == 0:\n", + " print(\"No tile found with valid hits.\")\n", + " return\n", + "\n", + " # Select the first tile that meets the condition.\n", + " img_idx = indices[0][0]\n", + " tile_idx = indices[1][0]\n", + " print(f\"Image index: {img_idx}, Tile index: {tile_idx} with {global_presence_max} hits.\")\n", + "\n", + " # Retrieve and display the corresponding tile image.\n", + " tile_image = normalized_images[img_idx, tile_idx]\n", + " \n", + " plt.imshow(tile_image, cmap='gray')\n", + " plt.title(f\"Image {img_idx} Tile {tile_idx} with {global_presence_max} valid hits\")\n", + " plt.axis('off')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "show_tile_with_global_max(data_loader)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(image)\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='yellow', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='yellow', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'ro', markersize=3)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "# z=np.random.randint(0,100)\n", + "z=9470\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def gating(tensor):\n", + " raw_p = tensor[..., 0] # shape (batch, max_hits)\n", + " xy = tensor[..., 1:3] # shape (batch, max_hits, 2)\n", + " p = tf.sigmoid(raw_p) # convert logit -> [0..1]\n", + " \n", + " gate = tf.where(p > 0.5, 1.0, 0.0)\n", + " gate = tf.expand_dims(gate, axis=-1) # (batch, max_hits, 1)\n", + " \n", + " xy_gated = xy * gate\n", + " p = tf.expand_dims(p, axis=-1) # shape (batch, max_hits, 1)\n", + "\n", + " return tf.concat([p, xy_gated], axis=-1) # shape (batch, max_hits, 3)\n", + "\n", + "def create_model(input_shape=(16, 16, 1), max_hits=7):\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional layers\n", + " x = layers.Conv2D(16, kernel_size=3,strides=2, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x) \n", + " x = layers.Conv2D(32, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(8, activation='relu')(x)\n", + "\n", + " # Final dense -> 3 values per hit: (raw_p, x, y)\n", + " x = layers.Dense(max_hits * 3, activation='linear')(x)\n", + " x = layers.Reshape((max_hits, 3))(x) # shape: (batch, max_hits, 3)\n", + "\n", + " # Apply gating\n", + " outputs = layers.Lambda(gating)(x)\n", + " model = Model(inputs, outputs, name=\"GatedModel\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def generalized_gating_loss(y_true, y_pred):\n", + " \"\"\"\n", + " Generalized gating loss for any number of hits per tile.\n", + " - BCE on p\n", + " - MSE on x,y (only for slots where p_true = 1)\n", + " \n", + " Inputs:\n", + " y_true, y_pred: (B, max_hits, 3)\n", + " Returns:\n", + " scalar loss\n", + " \"\"\"\n", + " # Separate components\n", + " p_true = y_true[..., 0]\n", + " p_pred = y_pred[..., 0]\n", + " xy_true = y_true[..., 1:3]\n", + " xy_pred = y_pred[..., 1:3]\n", + "\n", + " # 1. Presence loss (binary cross entropy)\n", + " bce = tf.keras.losses.binary_crossentropy(p_true, p_pred)\n", + " loss_p = tf.reduce_mean(bce)\n", + "\n", + " # 2. Coordinate loss (MSE only where p_true = 1)\n", + " mask = tf.expand_dims(tf.cast(p_true > 0.5, tf.float32), axis=-1) # shape: (B, max_hits, 1)\n", + " mse_xy = tf.square(xy_true - xy_pred) * mask\n", + " loss_xy = tf.reduce_sum(mse_xy) / (tf.reduce_sum(mask) + 1e-10)\n", + "\n", + " return loss_p + loss_xy\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "from tensorflow.keras.optimizers import Adam\n", + "\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=5, verbose=1, mode='min', min_lr=5e-6)\n", + "\n", + "model = create_model()\n", + "model.compile(optimizer=Adam(learning_rate = 0.001), loss = generalized_gating_loss) \n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=35,\n", + " \n", + " callbacks=[lr_scheduler]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "from M3LearningLab.Major_Functions.overall_training import plot_training_history\n", + "plot_training_history(history)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "\n", + "model.save('/home/m3-learning/Documents/Research_Electron_Counting/ComputerVision_ObjectDetection_ElectronCounting/M3LearningLab/Trained_Weights/10KFixed_100_256by256_Small_95indexNoNoise.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "tiled_images, tiled_midpoint_coordinates = data_loader.normalize_data()\n", + "print(\"Tiled images shape:\", tiled_images.shape)\n", + "print(\"Normalized centers shape:\", tiled_midpoint_coordinates.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "i = np.random.randint(0, len(tiled_images)) ### index of the image you want to predict.\n", + "Derrick_predictions = model.predict(tiled_images[i,:,:,:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " image_size = num_tiles_per_row * tile_size\n", + " full_image = np.zeros((image_size, image_size))\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " full_image[row:row+tile_size, col:col+tile_size] = tile.squeeze()\n", + " return full_image\n", + "\n", + "def visualize_image_with_predictions(image_tiles, predicted_image, tile_size=8, p_threshold=0.5):\n", + " grid_size = int(np.sqrt(len(image_tiles)))\n", + " full_image = reconstruct_image_from_tiles(image_tiles, tile_size, grid_size)\n", + " plt.figure(figsize=(10, 10))\n", + " plt.imshow(full_image, cmap='gray')\n", + "\n", + " for tile_idx, hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + " for p, x, y in hits:\n", + " if p > p_threshold:\n", + " gx = col_offset + x * tile_size\n", + " gy = row_offset + y * tile_size\n", + " plt.scatter(gx, gy, color='red', s=5)\n", + "\n", + " plt.title(\"Reconstructed Image with Predictions\")\n", + " plt.axis('on')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "visualize_image_with_predictions(tiled_images[i,:,:,:], Derrick_predictions, tile_size=16, p_threshold=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "plt.imshow(images[i], cmap='gray')\n", + "for prob, x, y in centers[i]:\n", + " if prob > 0:\n", + " plt.scatter(x, y, color='green', s=10, marker='x')\n", + "plt.title(\"Image with Ground Truth Centers\")\n", + "plt.axis('on')\n", + "plt.show()" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ComputerVision_OD_Electron_Counting/What_If_RF_is_8.ipynb b/ComputerVision_OD_Electron_Counting/What_If_RF_is_8.ipynb new file mode 100644 index 0000000..465e6e1 --- /dev/null +++ b/ComputerVision_OD_Electron_Counting/What_If_RF_is_8.ipynb @@ -0,0 +1,5712 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6b5a6fcd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 00:25:21.155403: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-05-23 00:25:21.170820: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1747974321.184589 865239 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1747974321.188804 865239 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1747974321.202902 865239 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747974321.202918 865239 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747974321.202919 865239 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1747974321.202921 865239 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2025-05-23 00:25:21.206923: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:2',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I0000 00:00:1747974323.491541 865239 gpu_device.cc:2019] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79194 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"2\" # Only GPUs 6 and 7 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:2\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "534e7c3e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "05c9821e", + "metadata": {}, + "outputs": [], + "source": [ + "import h5py, numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# ─── geometry constants ─────────────────────────────────────────\n", + "IMAGE_SIZE = 256\n", + "GRID = 32\n", + "STRIDE = 8\n", + "RF_SIZE = 8\n", + "OFFSET = 0\n", + "MAX_HITS = 2\n", + "# ────────────────────────────────────────────────────────────────\n", + "\n", + "def build_label(hit_array: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " hit_array: (M,3) rows = [id, x_px, y_px] in 64×64 coords\n", + " returns : (32,32,MAX_HITS,3) with slots [p, nx, ny]\n", + " \"\"\"\n", + " lbl = np.zeros((GRID, GRID, MAX_HITS, 3), dtype=np.float32)\n", + " slot_idx = np.zeros((GRID, GRID), dtype=np.int8)\n", + "\n", + " for _i, x_px, y_px in hit_array:\n", + " # 1) which output cell\n", + " c = int(x_px // STRIDE)\n", + " r = int(y_px // STRIDE)\n", + " if not (0 <= r < GRID and 0 <= c < GRID):\n", + " continue\n", + "\n", + " k = slot_idx[r, c]\n", + " if k >= MAX_HITS:\n", + " continue\n", + "\n", + " # 2) top‐left of this RF in input space\n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + "\n", + " # 3) local normalised coords\n", + " nx = (x_px - x0) / RF_SIZE\n", + " ny = (y_px - y0) / RF_SIZE\n", + " # nx = np.clip(nx, 0.0, 1)\n", + " # ny = np.clip(ny, 0.0, 1)\n", + "\n", + " # 4) write slot\n", + " lbl[r, c, k, 0] = 1.0\n", + " lbl[r, c, k, 1] = nx\n", + " lbl[r, c, k, 2] = ny\n", + " slot_idx[r, c] += 1\n", + "\n", + " return lbl\n", + "\n", + "\n", + "def load_dataset(h5_path: str, max_samples: int = None):\n", + " \"\"\"Returns X:(N,64,64,1), y:(N,32,32,MAX_HITS,3)\"\"\"\n", + " with h5py.File(h5_path, \"r\") as f:\n", + " imgs = np.asarray(f[\"images\"][:max_samples], np.float32)\n", + " centers = np.asarray(f[\"centers_training\"][:max_samples]) # (N,M,3)\n", + "\n", + " # normalize + add channel\n", + " X = imgs / (imgs.max() + 1e-7)\n", + " X = X[..., None] # (N,64,64,1)\n", + "\n", + " # build per‐frame label\n", + " y = np.stack([build_label(hits) for hits in centers], axis=0)\n", + " # y.shape == (N,32,32,MAX_HITS,3)\n", + "\n", + " return X, y\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c4d5037e", + "metadata": {}, + "outputs": [], + "source": [ + "h5_file = \"/home/da886/ComputerVision_OD_Electron_Counting/Images_and_Labels/50KFixed_100_256by256_RandomindexNoNoise.h5\"\n", + "X_images,y_labels = load_dataset(h5_file, max_samples=12000) " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c0c76472", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: (11400, 256, 256, 1) (11400, 32, 32, 2, 3)\n", + " Val : (600, 256, 256, 1) (600, 32, 32, 2, 3)\n" + ] + } + ], + "source": [ + "X_train, X_val, y_train, y_val = train_test_split(\n", + " X_images, y_labels,\n", + " test_size=0.05,\n", + " random_state=42,\n", + " shuffle=True\n", + ")\n", + "\n", + "print(\"Train:\", X_train.shape, y_train.shape)\n", + "print(\" Val :\", X_val.shape, y_val.shape)\n", + "\n", + "# 3) Build tf.data pipelines\n", + "batch_size = 64\n", + "\n", + "train_ds = (\n", + " tf.data.Dataset\n", + " .from_tensor_slices((X_train, y_train))\n", + " .shuffle(buffer_size=len(X_train), seed=42)\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE)\n", + ")\n", + "\n", + "val_ds = (\n", + " tf.data.Dataset\n", + " .from_tensor_slices((X_val, y_val))\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "7a39bad4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float32(1.0), np.float32(0.0))" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(y_labels), np.min(y_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "794b6532", + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "# from tensorflow.keras import layers, Model\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def gating_spatial(tensor):\n", + "# raw_p = tensor[..., 0] \n", + "# xy = tensor[..., 1:3] \n", + "# p = tf.sigmoid(raw_p)[..., None] \n", + "# gate = tf.cast(p > 0.5, tf.float32)\n", + "# xy_g = xy * gate\n", + " \n", + "# return tf.concat([p, xy_g], axis=-1) \n", + "\n", + "# def create_rf8_detector(input_shape=(256,256,1), max_hits=2):\n", + "# inp = layers.Input(shape=input_shape)\n", + "\n", + " \n", + "# x = layers.Conv2D(32, 3, padding='same', activation='relu')(inp)\n", + "# x = layers.MaxPooling2D(2,padding = 'same')(x) \n", + "# x = layers.Conv2D(16, 3, padding='same', activation='relu')(x) \n", + "# # x = layers.Conv2D(64, 3, padding='same', activation='relu')(x)\n", + " \n", + "\n", + " \n", + "# x = layers.Conv2D(max_hits*3, 1, padding='same')(x)\n", + "# x = layers.Reshape((128,128,max_hits,3))(x)\n", + "# out = layers.Lambda(gating_spatial)(x)\n", + " \n", + " \n", + "# return Model(inp, out, name=\"RF8_Detector\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "5589aecd", + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "from itertools import permutations\n", + "import numpy as np\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def gating_spatial(tensor):\n", + " raw_p = tensor[..., 0]\n", + " xy = tensor[..., 1:3]\n", + " p = tf.sigmoid(raw_p)[..., None]\n", + " gate = tf.cast(p > 0.5, tf.float32)\n", + " xy_g = xy * gate\n", + " return tf.concat([p, xy_g], axis=-1)\n", + "\n", + "eps = 1e-6\n", + " \n", + "\n", + "\n", + "class RF8Detector(tf.keras.Model):\n", + " \n", + " def __init__(self, input_shape=(256, 256, 1), max_hits=2):\n", + " super().__init__()\n", + " self.max_hits = max_hits\n", + " self.perms = tf.constant(list(permutations(range(max_hits))), tf.int32)\n", + " self.hit_weights = {1: 1.0, 2: 1.0} \n", + " \n", + " self.conv_block = tf.keras.Sequential([\n", + " layers.Conv2D(128, 2, strides=2, padding=\"valid\", activation=\"relu\",\n", + " input_shape=input_shape),\n", + " layers.Conv2D(128, 2, strides=2, padding=\"valid\", activation=\"relu\"),\n", + " layers.Conv2D(128, 2, strides=2, padding=\"valid\", activation=\"relu\"),\n", + " ])\n", + "\n", + " \n", + " self.output_block = tf.keras.Sequential([\n", + " layers.Conv2D(max_hits * 3, 1, padding=\"same\"),\n", + " layers.Reshape((32, 32, max_hits, 3)), \n", + " layers.Lambda(gating_spatial),\n", + " ])\n", + "\n", + " self.build((None,) + input_shape)\n", + "\n", + " def call(self, x):\n", + " x = self.conv_block(x) \n", + " return self.output_block(x)\n", + "\n", + " # def compute_permuted_loss(self, y_true, y_pred):\n", + " # p_true = y_true[..., 0] # (B,H,W,K)\n", + " # xy_true = y_true[..., 1:] # (B,H,W,K,2)\n", + " # p_pred = y_pred[..., 0] # (B,H,W,K)\n", + " # xy_pred = y_pred[..., 1:] # (B,H,W,K,2)\n", + " \n", + " # B, H, W, K = tf.unstack(tf.shape(p_true))\n", + " # N = B * H * W\n", + " \n", + " # # Reshape tensors\n", + " # p_t = tf.reshape(p_true, [N, K])\n", + " # xy_t = tf.reshape(xy_true, [N, K, 2])\n", + " # p_p = tf.reshape(p_pred, [N, K])\n", + " # xy_p = tf.reshape(xy_pred, [N, K, 2])\n", + " \n", + " # # 1. BCE in natural order with hit-count weighting\n", + " # bce = tf.keras.losses.binary_crossentropy(p_t, p_p) # (N,)\n", + " \n", + " # # 2. Find best permutation for MSE only\n", + " # xy_p_perm = tf.gather(xy_p, self.perms, axis=1) # (N,P,K,2)\n", + " # mask = tf.cast(p_t > 0.5, tf.float32)[:, tf.newaxis, :] # (N,1,K)\n", + " # se = tf.reduce_sum(tf.square(xy_t[:, tf.newaxis] - xy_p_perm), axis=-1) # (N,P,K)\n", + " # mse_per_perm = tf.reduce_sum(se * mask, axis=2) / (tf.reduce_sum(mask, axis=2) + eps) # (N,P)\n", + " # best_perm_idx = tf.argmin(mse_per_perm, axis=1) # (N,)\n", + " # best_mse = tf.gather(mse_per_perm, best_perm_idx, batch_dims=1) # (N,)\n", + " \n", + " # # 3. Apply hit-count weighting\n", + " # num_hits = tf.reduce_sum(tf.cast(p_t > 0.5, tf.int32), axis=1) # (N,)\n", + " # weights = tf.where(\n", + " # num_hits == 1, self.hit_weights[1],\n", + " # tf.where(num_hits == 2, self.hit_weights[2], 1.0)\n", + " # )\n", + " \n", + " # # 4. Compute weighted losses\n", + " # weighted_bce = bce * weights\n", + " # weighted_mse = best_mse * weights\n", + " \n", + " # return (\n", + " # tf.reduce_mean(weighted_bce) + tf.reduce_mean(weighted_mse),\n", + " # tf.reduce_mean(weighted_bce),\n", + " # tf.reduce_mean(weighted_mse)\n", + " # )\n", + " def compute_permuted_loss(self, y_true, y_pred):\n", + " # ─── unpack tensors ───────────────────────────────────────────\n", + " p_true, xy_true = y_true[..., 0], y_true[..., 1:] # (B,H,W,K) , (B,H,W,K,2)\n", + " p_pred, xy_pred = y_pred[..., 0], y_pred[..., 1:]\n", + "\n", + " B, H, W, K = tf.unstack(tf.shape(p_true))\n", + " N = B * H * W\n", + "\n", + " # ─── flatten spatial dims ─────────────────────────────────────\n", + " p_t = tf.reshape(p_true, [N, K]) # (N,K)\n", + " xy_t = tf.reshape(xy_true, [N, K, 2]) # (N,K,2)\n", + " p_p = tf.reshape(p_pred, [N, K])\n", + " xy_p = tf.reshape(xy_pred, [N, K, 2])\n", + "\n", + " # ─── 1) BCE (natural order) ──────────────────────────────────\n", + " bce = tf.keras.losses.binary_crossentropy(p_t, p_p) # (N,)\n", + "\n", + " # ─── 2) permutation-optimised MSE ───────────────────────────\n", + " xy_p_perm = tf.gather(xy_p, self.perms, axis=1) # (N,P,K,2)\n", + " mask = tf.cast(p_t > 0.5, tf.float32)[:, None] # (N,1,K)\n", + " se = tf.reduce_sum(tf.square(xy_t[:, None] - xy_p_perm), axis=-1) # (N,P,K)\n", + " mse_per_perm = tf.reduce_sum(se * mask, axis=2) / (tf.reduce_sum(mask, axis=2) + eps) # (N,P)\n", + " best_perm_idx = tf.argmin(mse_per_perm, axis=1) # (N,)\n", + " best_mse = tf.gather(mse_per_perm, best_perm_idx, batch_dims=1) # (N,)\n", + "\n", + " # ─── 3) hit-count weighting ─────────────────────────────────\n", + " num_hits = tf.reduce_sum(tf.cast(p_t > 0.5, tf.int32), axis=1) # (N,)\n", + " weights = tf.where(num_hits == 1, self.hit_weights[1],\n", + " tf.where(num_hits == 2, self.hit_weights[2], 1.0))\n", + "\n", + " weighted_bce = bce * weights # (N,)\n", + " weighted_mse = best_mse * weights # (N,)\n", + "\n", + " # ─── 4) *separate* means ────────────────────────────────────\n", + " mean_bce = tf.reduce_sum(weighted_bce) / tf.reduce_sum(weights) # all cells\n", + " active = tf.cast(num_hits > 0, tf.float32) # (N,)\n", + " mean_mse = (tf.reduce_sum(weighted_mse * active) /\n", + " tf.reduce_sum(weights * active) ) # only hit cells\n", + "\n", + " total_loss = mean_bce + mean_mse\n", + " return total_loss, mean_bce, mean_mse\n", + "\n", + " @tf.function\n", + " def train_step(self, data):\n", + " x, y_true = data\n", + " with tf.GradientTape() as tape:\n", + " y_pred = self(x, training=True)\n", + " total_loss, bce, mse = self.compute_permuted_loss(y_true, y_pred)\n", + " grads = tape.gradient(total_loss, self.trainable_variables)\n", + " self.optimizer.apply_gradients(zip(grads, self.trainable_variables))\n", + " return {'loss': total_loss, 'bce': bce, 'mse': mse}\n", + " \n", + " @tf.function\n", + " def test_step(self, data):\n", + " x, y_true = data\n", + " y_pred = self(x, training=False)\n", + " total_loss, bce, mse = self.compute_permuted_loss(y_true, y_pred)\n", + " return {'val_loss': total_loss, 'val_bce': bce, 'val_mse': mse}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0838934", + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "\n", + "# @tf.keras.utils.register_keras_serializable()\n", + "# def masked_bce_mse_loss(y_true, y_pred):\n", + "# \"\"\"\n", + "# Combined loss with:\n", + "# - BCE for slot probabilities (p)\n", + "# - Masked MSE for coordinates (xy) where p_true > 0\n", + " \n", + "# Args:\n", + "# y_true: Ground truth [p, x, y] with shape (..., K, 3)\n", + "# y_pred: Predictions [p, x, y] with shape (..., K, 3)\n", + "# Returns:\n", + "# Total loss = BCE + MSE (scalar)\n", + "# \"\"\"\n", + "# # Split components\n", + "# p_true = y_true[..., 0] # (..., K)\n", + "# xy_true = y_true[..., 1:] # (..., K, 2)\n", + "# p_pred = y_pred[..., 0] # (..., K) (must be sigmoid-activated)\n", + "# xy_pred = y_pred[..., 1:] # (..., K, 2)\n", + "\n", + "# # ===== 1. BCE Calculation =====\n", + "# bce = tf.keras.losses.binary_crossentropy(p_true, p_pred) # (..., K)\n", + "# bce = tf.reduce_mean(bce) # Scalar\n", + "\n", + "# # ===== 2. Masked MSE Calculation =====\n", + "# mask = tf.cast(p_true > 0, tf.float32) # (..., K)\n", + "# mask = tf.expand_dims(mask, axis=-1) # (..., K, 1) for broadcasting\n", + "# squared_error = tf.square(xy_true - xy_pred) # (..., K, 2)\n", + "# masked_se = squared_error * mask # Zero out inactive slots\n", + " \n", + "# # Normalize by active slots (avoid div-by-zero)\n", + "# active_slots = tf.reduce_sum(mask) + tf.keras.backend.epsilon()\n", + "# mse = tf.reduce_sum(masked_se) / active_slots # Scalar\n", + "\n", + "# # ===== 3. Combine Losses =====\n", + "# total_loss = bce + mse\n", + " \n", + "# # Optional: Track components separately\n", + "# tf.summary.scalar('bce', bce)\n", + "# tf.summary.scalar('mse', mse)\n", + " \n", + "# return total_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "f70d3a33", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/da886/anaconda3/envs/ObjectDetection2/lib/python3.11/site-packages/keras/src/layers/layer.py:396: UserWarning: `build()` was called on layer 'rf8_detector_3', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"rf8_detector_3\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"rf8_detector_3\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ sequential_6 (Sequential)       │ (None, 32, 32, 128)    │       131,968 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ sequential_7 (Sequential)       │ ?                      │   0 (unbuilt) │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ sequential_6 (\u001b[38;5;33mSequential\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m131,968\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ sequential_7 (\u001b[38;5;33mSequential\u001b[0m) │ ? │ \u001b[38;5;34m0\u001b[0m (unbuilt) │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 131,968 (515.50 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m131,968\u001b[0m (515.50 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 131,968 (515.50 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m131,968\u001b[0m (515.50 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tensorflow.keras.optimizers import Adam\n", + "\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=5, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " model = RF8Detector(input_shape=(256,256,1), max_hits=2)\n", + " model.compile(optimizer=Adam(learning_rate = 0.0001))\n", + " model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "8c74c95b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/120\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:12:26.870925: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 40ms/step - bce: 0.4750 - loss: 0.9978 - mse: 0.5228 - val_val_bce: 0.1776 - val_val_loss: 0.7304 - val_val_mse: 0.5528\n", + "Epoch 2/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 26ms/step - bce: 0.1717 - loss: 0.7205 - mse: 0.5488 - val_val_bce: 0.1700 - val_val_loss: 0.7229 - val_val_mse: 0.5528\n", + "Epoch 3/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.1636 - loss: 0.7127 - mse: 0.5491 - val_val_bce: 0.1543 - val_val_loss: 0.7071 - val_val_mse: 0.5528\n", + "Epoch 4/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 49ms/step - bce: 0.1256 - loss: 0.6487 - mse: 0.5231" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:12:57.614804: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 58ms/step - bce: 0.1254 - loss: 0.6479 - mse: 0.5224 - val_val_bce: 0.0914 - val_val_loss: 0.5071 - val_val_mse: 0.4157\n", + "Epoch 5/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 31ms/step - bce: 0.0677 - loss: 0.3193 - mse: 0.2516 - val_val_bce: 0.0556 - val_val_loss: 0.1982 - val_val_mse: 0.1426\n", + "Epoch 6/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0495 - loss: 0.1627 - mse: 0.1133 - val_val_bce: 0.0484 - val_val_loss: 0.1506 - val_val_mse: 0.1022\n", + "Epoch 7/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 31ms/step - bce: 0.0452 - loss: 0.1330 - mse: 0.0878 - val_val_bce: 0.0456 - val_val_loss: 0.1330 - val_val_mse: 0.0874\n", + "Epoch 8/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 46ms/step - bce: 0.0430 - loss: 0.1206 - mse: 0.0777 - val_val_bce: 0.0435 - val_val_loss: 0.1236 - val_val_mse: 0.0802\n", + "Epoch 9/120\n", + "\u001b[1m176/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 24ms/step - bce: 0.0409 - loss: 0.1131 - mse: 0.0722" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:13:30.499790: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 29ms/step - bce: 0.0408 - loss: 0.1129 - mse: 0.0721 - val_val_bce: 0.0412 - val_val_loss: 0.1140 - val_val_mse: 0.0728\n", + "Epoch 10/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0386 - loss: 0.1060 - mse: 0.0674 - val_val_bce: 0.0386 - val_val_loss: 0.1081 - val_val_mse: 0.0696\n", + "Epoch 11/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 41ms/step - bce: 0.0359 - loss: 0.0990 - mse: 0.0631 - val_val_bce: 0.0351 - val_val_loss: 0.1010 - val_val_mse: 0.0658\n", + "Epoch 12/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 44ms/step - bce: 0.0328 - loss: 0.0913 - mse: 0.0586 - val_val_bce: 0.0318 - val_val_loss: 0.0865 - val_val_mse: 0.0548\n", + "Epoch 13/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - bce: 0.0303 - loss: 0.0851 - mse: 0.0548 - val_val_bce: 0.0297 - val_val_loss: 0.0835 - val_val_mse: 0.0538\n", + "Epoch 14/120\n", + "\u001b[1m176/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 23ms/step - bce: 0.0292 - loss: 0.0818 - mse: 0.0527" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:14:04.501387: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 29ms/step - bce: 0.0292 - loss: 0.0819 - mse: 0.0527 - val_val_bce: 0.0290 - val_val_loss: 0.0797 - val_val_mse: 0.0507\n", + "Epoch 15/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 51ms/step - bce: 0.0286 - loss: 0.0794 - mse: 0.0508 - val_val_bce: 0.0285 - val_val_loss: 0.0780 - val_val_mse: 0.0494\n", + "Epoch 16/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0283 - loss: 0.0777 - mse: 0.0494 - val_val_bce: 0.0283 - val_val_loss: 0.0760 - val_val_mse: 0.0477\n", + "Epoch 17/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 35ms/step - bce: 0.0280 - loss: 0.0762 - mse: 0.0483 - val_val_bce: 0.0280 - val_val_loss: 0.0753 - val_val_mse: 0.0474\n", + "Epoch 18/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 32ms/step - bce: 0.0278 - loss: 0.0752 - mse: 0.0474" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:14:34.897022: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 37ms/step - bce: 0.0278 - loss: 0.0753 - mse: 0.0476 - val_val_bce: 0.0278 - val_val_loss: 0.0737 - val_val_mse: 0.0459\n", + "Epoch 19/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 41ms/step - bce: 0.0276 - loss: 0.0745 - mse: 0.0469 - val_val_bce: 0.0276 - val_val_loss: 0.0708 - val_val_mse: 0.0432\n", + "Epoch 20/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 27ms/step - bce: 0.0274 - loss: 0.0736 - mse: 0.0462 - val_val_bce: 0.0274 - val_val_loss: 0.0753 - val_val_mse: 0.0479\n", + "Epoch 21/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 35ms/step - bce: 0.0273 - loss: 0.0731 - mse: 0.0458 - val_val_bce: 0.0273 - val_val_loss: 0.0714 - val_val_mse: 0.0441\n", + "Epoch 22/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 53ms/step - bce: 0.0271 - loss: 0.0726 - mse: 0.0455 - val_val_bce: 0.0271 - val_val_loss: 0.0707 - val_val_mse: 0.0436\n", + "Epoch 23/120\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:15:05.010323: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0270 - loss: 0.0721 - mse: 0.0452 - val_val_bce: 0.0270 - val_val_loss: 0.0708 - val_val_mse: 0.0438\n", + "Epoch 24/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 25ms/step - bce: 0.0268 - loss: 0.0714 - mse: 0.0446 - val_val_bce: 0.0269 - val_val_loss: 0.0710 - val_val_mse: 0.0441\n", + "Epoch 25/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 31ms/step - bce: 0.0267 - loss: 0.0713 - mse: 0.0446 - val_val_bce: 0.0268 - val_val_loss: 0.0701 - val_val_mse: 0.0433\n", + "Epoch 26/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 53ms/step - bce: 0.0266 - loss: 0.0710 - mse: 0.0444 - val_val_bce: 0.0267 - val_val_loss: 0.0717 - val_val_mse: 0.0450\n", + "Epoch 27/120\n", + "\u001b[1m177/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 27ms/step - bce: 0.0265 - loss: 0.0708 - mse: 0.0443" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:15:38.059030: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0265 - loss: 0.0707 - mse: 0.0442 - val_val_bce: 0.0266 - val_val_loss: 0.0695 - val_val_mse: 0.0429\n", + "Epoch 28/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0264 - loss: 0.0706 - mse: 0.0442 - val_val_bce: 0.0265 - val_val_loss: 0.0693 - val_val_mse: 0.0428\n", + "Epoch 29/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - bce: 0.0263 - loss: 0.0702 - mse: 0.0439 - val_val_bce: 0.0264 - val_val_loss: 0.0707 - val_val_mse: 0.0442\n", + "Epoch 30/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 45ms/step - bce: 0.0262 - loss: 0.0698 - mse: 0.0436 - val_val_bce: 0.0264 - val_val_loss: 0.0683 - val_val_mse: 0.0419\n", + "Epoch 31/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0262 - loss: 0.0697 - mse: 0.0436 - val_val_bce: 0.0263 - val_val_loss: 0.0708 - val_val_mse: 0.0445\n", + "Epoch 32/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 29ms/step - bce: 0.0261 - loss: 0.0695 - mse: 0.0434" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:16:11.430640: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 34ms/step - bce: 0.0261 - loss: 0.0696 - mse: 0.0435 - val_val_bce: 0.0262 - val_val_loss: 0.0701 - val_val_mse: 0.0439\n", + "Epoch 33/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 37ms/step - bce: 0.0260 - loss: 0.0693 - mse: 0.0433 - val_val_bce: 0.0261 - val_val_loss: 0.0686 - val_val_mse: 0.0424\n", + "Epoch 34/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 42ms/step - bce: 0.0259 - loss: 0.0691 - mse: 0.0432 - val_val_bce: 0.0260 - val_val_loss: 0.0676 - val_val_mse: 0.0416\n", + "Epoch 35/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 25ms/step - bce: 0.0259 - loss: 0.0688 - mse: 0.0429 - val_val_bce: 0.0260 - val_val_loss: 0.0666 - val_val_mse: 0.0405\n", + "Epoch 36/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 37ms/step - bce: 0.0258 - loss: 0.0687 - mse: 0.0429 - val_val_bce: 0.0259 - val_val_loss: 0.0683 - val_val_mse: 0.0424\n", + "Epoch 37/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 50ms/step - bce: 0.0257 - loss: 0.0685 - mse: 0.0427" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:16:48.827401: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 55ms/step - bce: 0.0257 - loss: 0.0684 - mse: 0.0427 - val_val_bce: 0.0258 - val_val_loss: 0.0676 - val_val_mse: 0.0418\n", + "Epoch 38/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0257 - loss: 0.0683 - mse: 0.0427 - val_val_bce: 0.0257 - val_val_loss: 0.0665 - val_val_mse: 0.0407\n", + "Epoch 39/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 29ms/step - bce: 0.0256 - loss: 0.0683 - mse: 0.0427 - val_val_bce: 0.0257 - val_val_loss: 0.0691 - val_val_mse: 0.0434\n", + "Epoch 40/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - bce: 0.0255 - loss: 0.0680 - mse: 0.0424 - val_val_bce: 0.0256 - val_val_loss: 0.0682 - val_val_mse: 0.0426\n", + "Epoch 41/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 44ms/step - bce: 0.0255 - loss: 0.0679 - mse: 0.0424 - val_val_bce: 0.0255 - val_val_loss: 0.0684 - val_val_mse: 0.0429\n", + "Epoch 42/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step - bce: 0.0254 - loss: 0.0679 - mse: 0.0424" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:17:21.405732: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0254 - loss: 0.0678 - mse: 0.0424 - val_val_bce: 0.0255 - val_val_loss: 0.0650 - val_val_mse: 0.0394\n", + "Epoch 43/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0254 - loss: 0.0678 - mse: 0.0424 - val_val_bce: 0.0254 - val_val_loss: 0.0677 - val_val_mse: 0.0422\n", + "Epoch 44/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 38ms/step - bce: 0.0254 - loss: 0.0680 - mse: 0.0426 - val_val_bce: 0.0254 - val_val_loss: 0.0655 - val_val_mse: 0.0401\n", + "Epoch 45/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 50ms/step - bce: 0.0253 - loss: 0.0676 - mse: 0.0423 - val_val_bce: 0.0253 - val_val_loss: 0.0695 - val_val_mse: 0.0443\n", + "Epoch 46/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 26ms/step - bce: 0.0253 - loss: 0.0677 - mse: 0.0424 - val_val_bce: 0.0253 - val_val_loss: 0.0646 - val_val_mse: 0.0393\n", + "Epoch 47/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 27ms/step - bce: 0.0252 - loss: 0.0676 - mse: 0.0424" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:17:55.629120: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0252 - loss: 0.0676 - mse: 0.0424 - val_val_bce: 0.0252 - val_val_loss: 0.0670 - val_val_mse: 0.0418\n", + "Epoch 48/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 49ms/step - bce: 0.0252 - loss: 0.0675 - mse: 0.0423 - val_val_bce: 0.0252 - val_val_loss: 0.0661 - val_val_mse: 0.0409\n", + "Epoch 49/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 29ms/step - bce: 0.0251 - loss: 0.0675 - mse: 0.0424 - val_val_bce: 0.0251 - val_val_loss: 0.0671 - val_val_mse: 0.0420\n", + "Epoch 50/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 35ms/step - bce: 0.0251 - loss: 0.0675 - mse: 0.0424 - val_val_bce: 0.0251 - val_val_loss: 0.0649 - val_val_mse: 0.0398\n", + "Epoch 51/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 46ms/step - bce: 0.0250 - loss: 0.0675 - mse: 0.0424" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:18:31.880014: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 51ms/step - bce: 0.0250 - loss: 0.0673 - mse: 0.0423 - val_val_bce: 0.0250 - val_val_loss: 0.0692 - val_val_mse: 0.0443\n", + "Epoch 52/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 34ms/step - bce: 0.0250 - loss: 0.0672 - mse: 0.0422 - val_val_bce: 0.0249 - val_val_loss: 0.0698 - val_val_mse: 0.0449\n", + "Epoch 53/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 29ms/step - bce: 0.0250 - loss: 0.0673 - mse: 0.0424 - val_val_bce: 0.0249 - val_val_loss: 0.0673 - val_val_mse: 0.0423\n", + "Epoch 54/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 31ms/step - bce: 0.0249 - loss: 0.0672 - mse: 0.0423 - val_val_bce: 0.0248 - val_val_loss: 0.0684 - val_val_mse: 0.0435\n", + "Epoch 55/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 46ms/step - bce: 0.0249 - loss: 0.0672 - mse: 0.0423 - val_val_bce: 0.0248 - val_val_loss: 0.0683 - val_val_mse: 0.0435\n", + "Epoch 56/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step - bce: 0.0248 - loss: 0.0671 - mse: 0.0422" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:19:04.882429: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - bce: 0.0248 - loss: 0.0670 - mse: 0.0422 - val_val_bce: 0.0248 - val_val_loss: 0.0688 - val_val_mse: 0.0440\n", + "Epoch 57/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 31ms/step - bce: 0.0248 - loss: 0.0671 - mse: 0.0423 - val_val_bce: 0.0247 - val_val_loss: 0.0676 - val_val_mse: 0.0429\n", + "Epoch 58/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 29ms/step - bce: 0.0248 - loss: 0.0672 - mse: 0.0424 - val_val_bce: 0.0247 - val_val_loss: 0.0685 - val_val_mse: 0.0438\n", + "Epoch 59/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 47ms/step - bce: 0.0248 - loss: 0.0670 - mse: 0.0423 - val_val_bce: 0.0247 - val_val_loss: 0.0656 - val_val_mse: 0.0409\n", + "Epoch 60/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - bce: 0.0247 - loss: 0.0670 - mse: 0.0423 - val_val_bce: 0.0246 - val_val_loss: 0.0679 - val_val_mse: 0.0434\n", + "Epoch 61/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 24ms/step - bce: 0.0247 - loss: 0.0669 - mse: 0.0422" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:19:36.834181: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 29ms/step - bce: 0.0246 - loss: 0.0667 - mse: 0.0421 - val_val_bce: 0.0246 - val_val_loss: 0.0663 - val_val_mse: 0.0417\n", + "Epoch 62/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 29ms/step - bce: 0.0247 - loss: 0.0668 - mse: 0.0422 - val_val_bce: 0.0245 - val_val_loss: 0.0679 - val_val_mse: 0.0435\n", + "Epoch 63/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 55ms/step - bce: 0.0246 - loss: 0.0668 - mse: 0.0422 - val_val_bce: 0.0244 - val_val_loss: 0.0689 - val_val_mse: 0.0445\n", + "Epoch 64/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 28ms/step - bce: 0.0245 - loss: 0.0666 - mse: 0.0421 - val_val_bce: 0.0244 - val_val_loss: 0.0689 - val_val_mse: 0.0445\n", + "Epoch 65/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 34ms/step - bce: 0.0245 - loss: 0.0667 - mse: 0.0421 - val_val_bce: 0.0244 - val_val_loss: 0.0683 - val_val_mse: 0.0440\n", + "Epoch 66/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 36ms/step - bce: 0.0245 - loss: 0.0667 - mse: 0.0422" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:20:12.611140: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 44ms/step - bce: 0.0245 - loss: 0.0667 - mse: 0.0422 - val_val_bce: 0.0244 - val_val_loss: 0.0679 - val_val_mse: 0.0436\n", + "Epoch 67/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 42ms/step - bce: 0.0245 - loss: 0.0667 - mse: 0.0422 - val_val_bce: 0.0243 - val_val_loss: 0.0690 - val_val_mse: 0.0448\n", + "Epoch 68/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0245 - loss: 0.0666 - mse: 0.0422 - val_val_bce: 0.0243 - val_val_loss: 0.0654 - val_val_mse: 0.0410\n", + "Epoch 69/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 56ms/step - bce: 0.0244 - loss: 0.0666 - mse: 0.0421" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:20:42.897309: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 61ms/step - bce: 0.0245 - loss: 0.0667 - mse: 0.0422 - val_val_bce: 0.0242 - val_val_loss: 0.0677 - val_val_mse: 0.0435\n", + "Epoch 70/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0244 - loss: 0.0665 - mse: 0.0420 - val_val_bce: 0.0242 - val_val_loss: 0.0656 - val_val_mse: 0.0414\n", + "Epoch 71/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0243 - loss: 0.0664 - mse: 0.0420 - val_val_bce: 0.0241 - val_val_loss: 0.0710 - val_val_mse: 0.0468\n", + "Epoch 72/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 34ms/step - bce: 0.0244 - loss: 0.0664 - mse: 0.0420 - val_val_bce: 0.0241 - val_val_loss: 0.0691 - val_val_mse: 0.0450\n", + "Epoch 73/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 50ms/step - bce: 0.0243 - loss: 0.0663 - mse: 0.0420 - val_val_bce: 0.0241 - val_val_loss: 0.0659 - val_val_mse: 0.0418\n", + "Epoch 74/120\n", + "\u001b[1m176/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 21ms/step - bce: 0.0243 - loss: 0.0665 - mse: 0.0422" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:21:16.691114: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 26ms/step - bce: 0.0243 - loss: 0.0666 - mse: 0.0423 - val_val_bce: 0.0240 - val_val_loss: 0.0668 - val_val_mse: 0.0428\n", + "Epoch 75/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 31ms/step - bce: 0.0243 - loss: 0.0664 - mse: 0.0421 - val_val_bce: 0.0241 - val_val_loss: 0.0655 - val_val_mse: 0.0414\n", + "Epoch 76/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 53ms/step - bce: 0.0243 - loss: 0.0662 - mse: 0.0420 - val_val_bce: 0.0240 - val_val_loss: 0.0667 - val_val_mse: 0.0427\n", + "Epoch 77/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 28ms/step - bce: 0.0242 - loss: 0.0664 - mse: 0.0422 - val_val_bce: 0.0240 - val_val_loss: 0.0656 - val_val_mse: 0.0416\n", + "Epoch 78/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 29ms/step - bce: 0.0242 - loss: 0.0664 - mse: 0.0422" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:21:49.657809: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 34ms/step - bce: 0.0242 - loss: 0.0665 - mse: 0.0423 - val_val_bce: 0.0240 - val_val_loss: 0.0658 - val_val_mse: 0.0418\n", + "Epoch 79/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 52ms/step - bce: 0.0242 - loss: 0.0663 - mse: 0.0421 - val_val_bce: 0.0239 - val_val_loss: 0.0673 - val_val_mse: 0.0434\n", + "Epoch 80/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 39ms/step - bce: 0.0241 - loss: 0.0662 - mse: 0.0421 - val_val_bce: 0.0239 - val_val_loss: 0.0690 - val_val_mse: 0.0451\n", + "Epoch 81/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0241 - loss: 0.0664 - mse: 0.0423 - val_val_bce: 0.0239 - val_val_loss: 0.0658 - val_val_mse: 0.0419\n", + "Epoch 82/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 29ms/step - bce: 0.0241 - loss: 0.0663 - mse: 0.0422" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:22:19.799657: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 36ms/step - bce: 0.0241 - loss: 0.0663 - mse: 0.0422 - val_val_bce: 0.0238 - val_val_loss: 0.0683 - val_val_mse: 0.0445\n", + "Epoch 83/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 48ms/step - bce: 0.0241 - loss: 0.0662 - mse: 0.0421 - val_val_bce: 0.0238 - val_val_loss: 0.0686 - val_val_mse: 0.0447\n", + "Epoch 84/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - bce: 0.0241 - loss: 0.0663 - mse: 0.0422 - val_val_bce: 0.0238 - val_val_loss: 0.0696 - val_val_mse: 0.0459\n", + "Epoch 85/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0241 - loss: 0.0662 - mse: 0.0422 - val_val_bce: 0.0238 - val_val_loss: 0.0656 - val_val_mse: 0.0418\n", + "Epoch 86/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 47ms/step - bce: 0.0240 - loss: 0.0662 - mse: 0.0421" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:22:50.923238: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 53ms/step - bce: 0.0240 - loss: 0.0662 - mse: 0.0421 - val_val_bce: 0.0237 - val_val_loss: 0.0688 - val_val_mse: 0.0451\n", + "Epoch 87/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 36ms/step - bce: 0.0240 - loss: 0.0662 - mse: 0.0422 - val_val_bce: 0.0237 - val_val_loss: 0.0686 - val_val_mse: 0.0449\n", + "Epoch 88/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0240 - loss: 0.0662 - mse: 0.0422 - val_val_bce: 0.0237 - val_val_loss: 0.0658 - val_val_mse: 0.0420\n", + "Epoch 89/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 59ms/step - bce: 0.0240 - loss: 0.0665 - mse: 0.0424 - val_val_bce: 0.0237 - val_val_loss: 0.0655 - val_val_mse: 0.0418\n", + "Epoch 90/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 25ms/step - bce: 0.0240 - loss: 0.0662 - mse: 0.0422" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:23:24.853593: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - bce: 0.0240 - loss: 0.0663 - mse: 0.0423 - val_val_bce: 0.0237 - val_val_loss: 0.0669 - val_val_mse: 0.0432\n", + "Epoch 91/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 34ms/step - bce: 0.0239 - loss: 0.0661 - mse: 0.0421 - val_val_bce: 0.0237 - val_val_loss: 0.0654 - val_val_mse: 0.0417\n", + "Epoch 92/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 50ms/step - bce: 0.0239 - loss: 0.0662 - mse: 0.0422 - val_val_bce: 0.0236 - val_val_loss: 0.0655 - val_val_mse: 0.0419\n", + "Epoch 93/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 40ms/step - bce: 0.0240 - loss: 0.0663 - mse: 0.0423 - val_val_bce: 0.0236 - val_val_loss: 0.0660 - val_val_mse: 0.0424\n", + "Epoch 94/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 25ms/step - bce: 0.0239 - loss: 0.0662 - mse: 0.0423 - val_val_bce: 0.0236 - val_val_loss: 0.0655 - val_val_mse: 0.0419\n", + "Epoch 95/120\n", + "\u001b[1m177/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 27ms/step - bce: 0.0239 - loss: 0.0661 - mse: 0.0422" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:24:00.016020: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0239 - loss: 0.0661 - mse: 0.0422 - val_val_bce: 0.0236 - val_val_loss: 0.0685 - val_val_mse: 0.0449\n", + "Epoch 96/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 58ms/step - bce: 0.0239 - loss: 0.0663 - mse: 0.0424 - val_val_bce: 0.0236 - val_val_loss: 0.0662 - val_val_mse: 0.0426\n", + "Epoch 97/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 31ms/step - bce: 0.0239 - loss: 0.0660 - mse: 0.0422 - val_val_bce: 0.0235 - val_val_loss: 0.0685 - val_val_mse: 0.0450\n", + "Epoch 98/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 34ms/step - bce: 0.0239 - loss: 0.0662 - mse: 0.0423 - val_val_bce: 0.0235 - val_val_loss: 0.0658 - val_val_mse: 0.0422\n", + "Epoch 99/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 33ms/step - bce: 0.0238 - loss: 0.0661 - mse: 0.0423" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:24:30.708034: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 39ms/step - bce: 0.0239 - loss: 0.0662 - mse: 0.0423 - val_val_bce: 0.0235 - val_val_loss: 0.0666 - val_val_mse: 0.0431\n", + "Epoch 100/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 50ms/step - bce: 0.0238 - loss: 0.0662 - mse: 0.0423 - val_val_bce: 0.0236 - val_val_loss: 0.0643 - val_val_mse: 0.0407\n", + "Epoch 101/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 27ms/step - bce: 0.0239 - loss: 0.0661 - mse: 0.0423 - val_val_bce: 0.0236 - val_val_loss: 0.0639 - val_val_mse: 0.0404\n", + "Epoch 102/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m15s\u001b[0m 52ms/step - bce: 0.0238 - loss: 0.0662 - mse: 0.0423 - val_val_bce: 0.0236 - val_val_loss: 0.0640 - val_val_mse: 0.0404\n", + "Epoch 103/120\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:25:00.717639: I tensorflow/core/framework/local_rendezvous.cc:407] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2025-05-23 01:25:00.767634: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 36ms/step - bce: 0.0238 - loss: 0.0660 - mse: 0.0422 - val_val_bce: 0.0236 - val_val_loss: 0.0649 - val_val_mse: 0.0413\n", + "Epoch 104/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 31ms/step - bce: 0.0238 - loss: 0.0659 - mse: 0.0422 - val_val_bce: 0.0234 - val_val_loss: 0.0686 - val_val_mse: 0.0452\n", + "Epoch 105/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 28ms/step - bce: 0.0238 - loss: 0.0661 - mse: 0.0423 - val_val_bce: 0.0234 - val_val_loss: 0.0680 - val_val_mse: 0.0445\n", + "Epoch 106/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 54ms/step - bce: 0.0238 - loss: 0.0662 - mse: 0.0424 - val_val_bce: 0.0234 - val_val_loss: 0.0657 - val_val_mse: 0.0423\n", + "Epoch 107/120\n", + "\u001b[1m178/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 21ms/step - bce: 0.0238 - loss: 0.0662 - mse: 0.0424" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:25:34.850797: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 26ms/step - bce: 0.0237 - loss: 0.0661 - mse: 0.0424 - val_val_bce: 0.0234 - val_val_loss: 0.0699 - val_val_mse: 0.0465\n", + "Epoch 108/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 33ms/step - bce: 0.0237 - loss: 0.0660 - mse: 0.0423 - val_val_bce: 0.0234 - val_val_loss: 0.0662 - val_val_mse: 0.0428\n", + "Epoch 109/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 34ms/step - bce: 0.0238 - loss: 0.0663 - mse: 0.0425 - val_val_bce: 0.0234 - val_val_loss: 0.0646 - val_val_mse: 0.0411\n", + "Epoch 110/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 52ms/step - bce: 0.0237 - loss: 0.0661 - mse: 0.0424 - val_val_bce: 0.0234 - val_val_loss: 0.0652 - val_val_mse: 0.0419\n", + "Epoch 111/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 26ms/step - bce: 0.0237 - loss: 0.0660 - mse: 0.0423 - val_val_bce: 0.0234 - val_val_loss: 0.0643 - val_val_mse: 0.0409\n", + "Epoch 112/120\n", + "\u001b[1m176/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 28ms/step - bce: 0.0237 - loss: 0.0660 - mse: 0.0423" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:26:08.743285: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 32ms/step - bce: 0.0237 - loss: 0.0659 - mse: 0.0422 - val_val_bce: 0.0234 - val_val_loss: 0.0642 - val_val_mse: 0.0408\n", + "Epoch 113/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 50ms/step - bce: 0.0237 - loss: 0.0661 - mse: 0.0424 - val_val_bce: 0.0234 - val_val_loss: 0.0639 - val_val_mse: 0.0405\n", + "Epoch 114/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 37ms/step - bce: 0.0237 - loss: 0.0660 - mse: 0.0424 - val_val_bce: 0.0233 - val_val_loss: 0.0655 - val_val_mse: 0.0422\n", + "Epoch 115/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 28ms/step - bce: 0.0237 - loss: 0.0662 - mse: 0.0424 - val_val_bce: 0.0235 - val_val_loss: 0.0624 - val_val_mse: 0.0389\n", + "Epoch 116/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 29ms/step - bce: 0.0237 - loss: 0.0661 - mse: 0.0425 - val_val_bce: 0.0233 - val_val_loss: 0.0665 - val_val_mse: 0.0432\n", + "Epoch 117/120\n", + "\u001b[1m177/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 47ms/step - bce: 0.0237 - loss: 0.0661 - mse: 0.0424" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:26:46.203202: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 53ms/step - bce: 0.0237 - loss: 0.0662 - mse: 0.0425 - val_val_bce: 0.0233 - val_val_loss: 0.0651 - val_val_mse: 0.0418\n", + "Epoch 118/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 30ms/step - bce: 0.0237 - loss: 0.0662 - mse: 0.0425 - val_val_bce: 0.0233 - val_val_loss: 0.0660 - val_val_mse: 0.0428\n", + "Epoch 119/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 35ms/step - bce: 0.0236 - loss: 0.0660 - mse: 0.0424 - val_val_bce: 0.0233 - val_val_loss: 0.0661 - val_val_mse: 0.0428\n", + "Epoch 120/120\n", + "\u001b[1m179/179\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 48ms/step - bce: 0.0236 - loss: 0.0663 - mse: 0.0426 - val_val_bce: 0.0233 - val_val_loss: 0.0645 - val_val_mse: 0.0412\n" + ] + } + ], + "source": [ + "history = model.fit(\n", + " train_ds,\n", + " validation_data=val_ds,\n", + " epochs=120\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "a1e187b4", + "metadata": {}, + "outputs": [], + "source": [ + "# import matplotlib.pyplot as plt\n", + "\n", + "# def plot_training_history(history):\n", + "# \"\"\"\n", + "# Plots the training and validation losses against epochs in a log scale,\n", + "# and the loss against the learning rate.\n", + "\n", + "# Parameters:\n", + "# - history: History object returned by model.fit, containing training metrics.\n", + "# \"\"\"\n", + "# epochs = range(len(history.history['loss']))\n", + "\n", + "# # Plot training and validation loss on a log scale\n", + "# plt.figure(figsize=(14, 6))\n", + " \n", + "# # Loss plot (log scale)\n", + "# plt.subplot(1, 2, 1)\n", + "# plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + "# plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + "# plt.yscale('log') # Logarithmic scale for loss\n", + "# plt.xlabel('Epochs')\n", + "# plt.ylabel('Loss (log scale)')\n", + "# plt.title('Training and Validation Loss (Log Scale)')\n", + "# plt.legend()\n", + "# plot_training_history(history)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "6413960c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_training_history(history):\n", + " plt.figure(figsize=(18, 6))\n", + " \n", + " # Total Loss (log scale)\n", + " plt.subplot(1, 3, 1)\n", + " plt.semilogy(history.history['loss'], 'b-', label='Train')\n", + " plt.semilogy(history.history['val_val_loss'], 'r-', label='Validation')\n", + " plt.title('Total Loss (Log Scale)')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Loss')\n", + " plt.legend()\n", + " plt.grid(True, which=\"both\", ls=\"-\")\n", + " \n", + " # BCE Loss (log scale)\n", + " plt.subplot(1, 3, 2)\n", + " plt.semilogy(history.history['bce'], 'b-', label='Train')\n", + " plt.semilogy(history.history['val_val_bce'], 'r-', label='Validation')\n", + " plt.title('BCE Loss (Log Scale)')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('BCE')\n", + " plt.legend()\n", + " plt.grid(True, which=\"both\", ls=\"-\")\n", + " \n", + " # MSE Loss (log scale)\n", + " plt.subplot(1, 3, 3)\n", + " plt.semilogy(history.history['mse'], 'b-', label='Train')\n", + " plt.semilogy(history.history['val_val_mse'], 'r-', label='Validation')\n", + " plt.title('MSE Loss (Log Scale)')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('MSE')\n", + " plt.legend()\n", + " plt.grid(True, which=\"both\", ls=\"-\")\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_training_history(history)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef082776", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" + ] + } + ], + "source": [ + "# model.save(\"/home/da886/ComputerVision_OD_Electron_Counting/Trained_Weights/RF_withPermutation_unweighted.h5\")" + ] + }, + { + "cell_type": "markdown", + "id": "a1c27d40", + "metadata": {}, + "source": [ + "### Sample Image and predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "f31d4a03", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_865239/1150070105.py:30: UserWarning: You passed both c and facecolor/facecolors for the markers. c has precedence over facecolor/facecolors. This behavior may change in the future.\n", + " plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "IMAGE_SIZE = 256\n", + "GRID = 32\n", + "STRIDE = 8\n", + "RF_SIZE = 8\n", + "OFFSET = 0\n", + "MAX_HITS = 2\n", + "idx = np.random.randint(len(X_images))\n", + "# idx =1722\n", + "img = X_images[idx,...,0]\n", + "gt_lbl = y_labels[idx]\n", + "pred_lbl = model.predict(img[None],verbose=0)[0]\n", + "\n", + "\n", + "def unpack(lbl_tensor, threshold=0.5):\n", + " \n", + " r,c,k = np.where(lbl_tensor[...,0] > threshold)\n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + " x = x0 + lbl_tensor[r,c,k,1]*RF_SIZE\n", + " y = y0 + lbl_tensor[r,c,k,2]*RF_SIZE\n", + " return x, y\n", + "\n", + "x_gt, y_gt = unpack(gt_lbl, threshold=0)\n", + "x_pr, y_pr = unpack(pred_lbl, threshold=0.5)\n", + "\n", + "plt.figure(figsize=(12,12))\n", + "plt.imshow(img,cmap='gray', origin=\"upper\")\n", + "plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "plt.scatter(x_gt, y_gt, c=\"red\", marker=\"x\", s=10, label=\"GT\")\n", + "# plt.scatter(x_pr, y_pr, c=\"lime\", marker=\"o\", s=10, facecolors=\"none\", label=\"Pred\")\n", + "plt.title(f\"Frame {idx}\")\n", + "plt.legend(loc=\"lower right\")\n", + "# plt.xlim(0,63); plt.ylim(63,0); plt.show()\n", + "plt.xlim(0,255); plt.ylim(255,0); plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "c163b1a1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def plot_probability_distributions(gt_lbl, pred_lbl, threshold=0.5):\n", + " \"\"\"\n", + " Show log-scaled histograms of predicted probabilities (p̂) for cells\n", + " with 0, 1, and 2 ground-truth hits.\n", + "\n", + " Parameters\n", + " ----------\n", + " gt_lbl : (128,128,K,3) ground-truth label tensor\n", + " pred_lbl : (128,128,K,3) model prediction tensor\n", + " threshold: float probability threshold used by gating (default 0.5)\n", + " \"\"\"\n", + " K = gt_lbl.shape[2] # number of slots per cell\n", + "\n", + " # ─── flatten cell → slot axis ─────────────────────────────────────────\n", + " p_true = gt_lbl [ ..., 0].reshape(-1, K) # (N,K)\n", + " p_pred = pred_lbl[..., 0].reshape(-1, K) # (N,K)\n", + " num_hits = (p_true > 0.5).sum(axis=1) # (N,)\n", + "\n", + " # collect predicted probabilities for each group\n", + " groups = {h: p_pred[num_hits == h].ravel() for h in (0, 1, 2)}\n", + "\n", + " # ─── one chart per hit-count (no sub-plots → matches training) ───────\n", + " for h in (0, 1, 2):\n", + " if groups[h].size == 0:\n", + " print(f\"No cells with {h} hit(s); skipping.\")\n", + " continue\n", + "\n", + " plt.figure(figsize=(6,4))\n", + " plt.hist(groups[h],\n", + " bins = np.linspace(0, 1, 51),\n", + " log = True, # y-axis on log scale\n", + " edgecolor='black')\n", + " plt.axvline(threshold, color='red', linestyle='--', linewidth=1)\n", + " plt.title(f\"Predicted probability distribution – {h}-hit cells\")\n", + " plt.xlabel(\"predicted probability (p̂)\")\n", + " plt.ylabel(\"count (log scale)\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "plot_probability_distributions(gt_lbl, pred_lbl, threshold=0.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "b292f04a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((32, 32, 2, 3), (32, 32, 2, 3))" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gt_lbl.shape, pred_lbl.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "15c46674", + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import pandas as pd\n", + "# import ace_tools_open as tools\n", + "# import tensorflow as tf\n", + "\n", + "# # ─── Hyperparameters ──────────────────────────────────────────\n", + "# eps = 1e-6\n", + "# λ_xy = 1.0 # weight on the MSE term\n", + "# # ──────────────────────────────────────────────────────────────\n", + "\n", + "# def compute_direct_loss(y_true, y_pred):\n", + "# \"\"\"Computes losses without any permutation matching\"\"\"\n", + "# p_true = y_true[..., 0] # (H,W,K)\n", + "# xy_true = y_true[..., 1:] # (H,W,K,2)\n", + "# p_pred = y_pred[..., 0] # (H,W,K)\n", + "# xy_pred = y_pred[..., 1:] # (H,W,K,2)\n", + " \n", + "# H, W, K = p_true.shape\n", + "# N = H * W\n", + " \n", + "# # Flatten tensors\n", + "# p_t = p_true.reshape(-1, K) # (N,K)\n", + "# xy_t = xy_true.reshape(-1, K, 2) # (N,K,2)\n", + "# p_p = p_pred.reshape(-1, K) # (N,K)\n", + "# xy_p = xy_pred.reshape(-1, K, 2) # (N,K,2)\n", + " \n", + "# # 1. BCE in natural order\n", + "# bce = tf.keras.losses.binary_crossentropy(p_t, p_p).numpy() # (N,)\n", + " \n", + "# # 2. MSE in natural order\n", + "# mask = (p_t > 0.5).astype(np.float32)[..., np.newaxis] # (N,K,1)\n", + "# se = np.sum((xy_t - xy_p)**2, axis=2) # (N,K)\n", + "# mse = np.sum(se * mask.squeeze(), axis=1) / (np.sum(mask, axis=(1,2)) + eps) # (N,)\n", + " \n", + "# total_loss = bce + λ_xy * mse\n", + " \n", + "# return total_loss, bce, mse\n", + "\n", + "# # ─── Analysis Execution ───────────────────────────────────────\n", + "# img = X_images[idx, ..., 0]\n", + "# gt_lbl = y_labels[idx] # (H,W,K,3)\n", + "# pred_lbl = model.predict(img[None], verbose=0)[0] # (H,W,K,3)\n", + "\n", + "# # Compute losses\n", + "# total_loss, bce, mse = compute_direct_loss(gt_lbl, pred_lbl)\n", + "\n", + "# # Create DataFrame\n", + "# H, W, K = gt_lbl.shape[:3]\n", + "# rows_idx, cols_idx = np.unravel_index(np.arange(H*W), (H, W))\n", + "# num_hits = (gt_lbl[..., 0] > 0.5).reshape(-1, K).sum(axis=1)\n", + "\n", + "# df_summary = pd.DataFrame({\n", + "# \"row\": rows_idx,\n", + "# \"col\": cols_idx,\n", + "# \"num_hits\": num_hits,\n", + "# \"BCE\": bce,\n", + "# \"MSE\": mse,\n", + "# \"combined\": total_loss\n", + "# })\n", + "\n", + "# def unpack_slots(selected):\n", + "# \"\"\"Unpack slot details in natural order\"\"\"\n", + "# records = []\n", + "# for _, cell in selected.iterrows():\n", + "# r, c = int(cell.row), int(cell.col)\n", + "# y_t = gt_lbl[r, c] # (K,3)\n", + "# y_p = pred_lbl[r, c] # (K,3)\n", + " \n", + "# for k in range(K):\n", + "# records.append({\n", + "# \"row\": r, \"col\": c, \"slot\": k,\n", + "# \"GT_p\": float(y_t[k, 0]),\n", + "# \"GT_x\": float(y_t[k, 1]), \n", + "# \"GT_y\": float(y_t[k, 2]),\n", + "# \"PR_p\": float(y_p[k, 0]),\n", + "# \"PR_x\": float(y_p[k, 1]), \n", + "# \"PR_y\": float(y_p[k, 2]),\n", + "# # \"dist\": np.sqrt((y_t[k,1]-y_p[k,1])**2 + (y_t[k,2]-y_p[k,2])**2) if y_t[k,0] > 0.5 else np.nan,\n", + "# \"cell_BCE\": float(cell.BCE) if k==0 else \"\",\n", + "# \"cell_MSE\": float(cell.MSE) if k==0 else \"\",\n", + "# \"combined\": float(cell.combined) if k==0 else \"\",\n", + "# })\n", + "# return pd.DataFrame(records)\n", + "\n", + "# # Generate sample tables\n", + "# tables = {}\n", + "# for hits in (1, 2):\n", + "# group = df_summary[df_summary['num_hits'] == hits]\n", + "# if not group.empty:\n", + "# best5 = group.nsmallest(5, 'combined')\n", + "# worst5 = group.nlargest(5, 'combined')\n", + "# tables[f'hits={hits} BEST'] = unpack_slots(best5)\n", + "# tables[f'hits={hits} WORST'] = unpack_slots(worst5)\n", + "\n", + "# # Display results\n", + "# for title, df in tables.items():\n", + "# tools.display_dataframe_to_user(title, df)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "id": "367c60f2", + "metadata": {}, + "outputs": [], + "source": [ + "mytrue = np.array([[1,0.625, 0.625],[0,0,0]])\n", + "mypred= np.array([[0.980844,0.609007,0.576857],[0.000387,0,0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "42b76663", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.00064338185\n" + ] + } + ], + "source": [ + "mse = tf.keras.losses.MeanSquaredError()\n", + "loss2 = mse(mytrue[...,1:], mypred[...,1:])\n", + "print(loss2.numpy())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "b09cfe59", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_coords = tf.reduce_mean(tf.square(mytrue[...,1:] - mypred[...,1:]))\n", + "loss_coords" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "c82eadb2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1. , 0.980844])" + ] + }, + "execution_count": 112, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mytrue[...,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "4fff6ae9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_prob = tf.keras.losses.binary_crossentropy(mytrue[...,0], mypred[...,0])\n", + "# loss_prob = tf.reduce_mean(loss_prob)\n", + "loss_prob" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "36848ab5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=1 BEST\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:29:59.794601: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=1 WORST\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=2 BEST\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hits=2 WORST\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "
rowcolslotGT_pGT_xGT_yPR_pPR_xPR_ycell_BCEcell_MSEcombined
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "Loading ITables v2.3.0 from the internet...\n", + "(need help?)
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "import pandas as pd\n", + "import ace_tools_open as tools\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from itertools import permutations\n", + "\n", + "# ─── constants copied from the model ──────────────────────────\n", + "HIT_WEIGHTS = {1: 1, 2: 1} # same as RF8Detector.hit_weights\n", + "eps = 1e-6\n", + "# ──────────────────────────────────────────────────────────────\n", + "\n", + "# def compute_analysis_loss(y_true, y_pred):\n", + "# \"\"\"\n", + "# Replicates RF8Detector.compute_permuted_loss *per cell*.\n", + "\n", + "# Returns\n", + "# -------\n", + "# total : (N,) weighted BCE + weighted MSE\n", + "# weighted_bce, weighted_mse, best_perm : (N,), (N,), (N,K)\n", + "# \"\"\"\n", + "# # shapes\n", + "# H, W, K, _ = y_true.shape\n", + "# N = H * W # cells in the image\n", + "# PERMS = np.array(list(permutations(range(K))), dtype=np.int32) # (P,K)\n", + "\n", + "# # flatten spatial dims -------------------------------------------------\n", + "# p_t = y_true[..., 0].reshape(N, K) # (N,K)\n", + "# xy_t = y_true[..., 1:].reshape(N, K, 2) # (N,K,2)\n", + "# p_p = y_pred[..., 0].reshape(N, K)\n", + "# xy_p = y_pred[..., 1:].reshape(N, K, 2)\n", + "\n", + "# # 1) BCE in natural order ----------------------------------------------\n", + "# bce = tf.keras.losses.binary_crossentropy(p_t, p_p).numpy() # (N,)\n", + "\n", + "# # 2) permutation-optimised MSE -----------------------------------------\n", + "# # xy_p → (N,1,K,2) so we can gather K coords for every perm at once\n", + "# xy_p_exp = xy_p[:, None] # (N,1,K,2)\n", + "# # PERMS → (1,P,K,1) so broadcasting matches xy_p_exp\n", + "# perm_idx = PERMS[None, :, :, None] # (1,P,K,1)\n", + "# xy_p_perm = np.take_along_axis(xy_p_exp, perm_idx, axis=2) # (N,P,K,2)\n", + "\n", + "# # squared error per slot & perm\n", + "# se = np.sum((xy_t[:, None] - xy_p_perm) ** 2, axis=-1) # (N,P,K)\n", + "# # se = np.mean((xy_t[:, None] - xy_p_perm) ** 2, axis=-1) ##################################### This part only does what Tensorflow's MSE does and only is accurate when there are 2 hits\n", + "\n", + "# # hit mask (N,1,K) so it broadcasts over perms\n", + "# mask = (p_t > 0.5).astype(np.float32)[:, None, :] # (N,1,K)\n", + "# mse_per_perm = np.sum(se * mask, axis=2) / (np.sum(mask, axis=2) + eps) # (N,P)\n", + "\n", + "# best_idx = np.argmin(mse_per_perm, axis=1) # (N,)\n", + "# best_mse = mse_per_perm[np.arange(N), best_idx] # (N,)\n", + "# best_perm = PERMS[best_idx] # (N,K)\n", + "\n", + "# # 3) hit-count weighting ----------------------------------------------\n", + "# num_hits = (p_t > 0.5).sum(axis=1) # (N,)\n", + "# weights = np.where(\n", + "# num_hits == 1, HIT_WEIGHTS[1],\n", + "# np.where(num_hits == 2, HIT_WEIGHTS[2], 1.0)\n", + "# )\n", + "\n", + "# weighted_bce = bce * weights\n", + "# weighted_mse = best_mse * weights\n", + "# total = weighted_bce + weighted_mse # NOTE: no λ_xy in training\n", + "\n", + "# return total, weighted_bce, weighted_mse, best_perm\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from itertools import permutations\n", + "\n", + "eps = 1e-6\n", + "PERMS_CACHE = {} # speeds things up if you call the function many times\n", + "\n", + "def compute_analysis_loss(y_true, y_pred):\n", + " \"\"\"\n", + " Per-cell BCE & permuted MSE, identical to the training logic.\n", + " Returns:\n", + " total (N,) = weighted_bce + weighted_mse\n", + " weighted_bce (N,)\n", + " weighted_mse (N,)\n", + " best_perm (N,K) slot order chosen for MSE\n", + " \"\"\"\n", + " H, W, K, _ = y_true.shape\n", + " N = H * W\n", + "\n", + " # --- permutation list (cached) ---------------------------------------\n", + " if K not in PERMS_CACHE:\n", + " PERMS_CACHE[K] = np.array(list(permutations(range(K))), dtype=np.int32)\n", + " PERMS = PERMS_CACHE[K] # (P,K)\n", + "\n", + " # --- flatten spatial dims --------------------------------------------\n", + " p_t = y_true[..., 0].reshape(N, K) # (N,K)\n", + " xy_t = y_true[..., 1:].reshape(N, K, 2) # (N,K,2)\n", + " p_p = y_pred[..., 0].reshape(N, K)\n", + " xy_p = y_pred[..., 1:].reshape(N, K, 2)\n", + "\n", + " # 1) BCE ---------------------------------------------------------------\n", + " bce = tf.keras.losses.binary_crossentropy(p_t, p_p).numpy() # (N,)\n", + "\n", + " # 2) permuted MSE ------------------------------------------------------\n", + " xy_p_perm = np.take_along_axis(\n", + " xy_p[:, None], # (N,1,K,2)\n", + " PERMS[None, :, :, None], # (1,P,K,1)\n", + " axis=2) # → (N,P,K,2)\n", + "\n", + " se = np.sum( # *** SUM over x & y (no /2)\n", + " (xy_t[:, None] - xy_p_perm) ** 2,\n", + " axis=-1) # (N,P,K)\n", + "\n", + " mask = (p_t > 0.5).astype(np.float32)[:, None] # (N,1,K)\n", + " mse_per_perm = np.sum(se * mask, axis=2) / (np.sum(mask, axis=2) + eps) # (N,P)\n", + "\n", + " best_idx = np.argmin(mse_per_perm, axis=1) # (N,)\n", + " best_mse = mse_per_perm[np.arange(N), best_idx]\n", + " best_perm = PERMS[best_idx]\n", + "\n", + " # 3) hit-count weighting ----------------------------------------------\n", + " num_hits = (p_t > 0.5).sum(axis=1) # (N,)\n", + " weights = np.where(num_hits == 1, HIT_WEIGHTS[1],\n", + " np.where(num_hits == 2, HIT_WEIGHTS[2], 1.0))\n", + "\n", + " weighted_bce = bce * weights # per-cell\n", + " weighted_mse = best_mse * weights\n", + "\n", + " total = weighted_bce + weighted_mse\n", + "\n", + " # (optional) global means exactly like training -----------------------\n", + " mean_bce = weighted_bce.mean() # all cells\n", + " active = num_hits > 0\n", + " mean_mse = weighted_mse[active].mean() if active.any() else 0.0 # only hits\n", + " mean_total_like_training = mean_bce + mean_mse\n", + "\n", + " # you can print or log these if you want to check:\n", + " # print(mean_bce, mean_mse, mean_total_like_training)\n", + "\n", + " return total, weighted_bce, weighted_mse, best_perm\n", + "\n", + "\n", + "# ─── Analysis Execution ───────────────────────────────────────\n", + "img = X_images[idx, ..., 0]\n", + "gt_lbl = y_labels[idx] # (H,W,K,3)\n", + "pred_lbl = model.predict(img[None], verbose=0)[0] # (H,W,K,3)\n", + "\n", + "# Compute losses\n", + "total_loss, bce, mse, best_perm = compute_analysis_loss(gt_lbl, pred_lbl)\n", + "\n", + "# Create DataFrame\n", + "H, W, K = gt_lbl.shape[:3]\n", + "rows_idx, cols_idx = np.unravel_index(np.arange(H*W), (H, W))\n", + "num_hits = (gt_lbl[..., 0] > 0.5).reshape(-1, K).sum(axis=1)\n", + "\n", + "df_summary = pd.DataFrame({\n", + " \"row\": rows_idx,\n", + " \"col\": cols_idx,\n", + " \"num_hits\": num_hits,\n", + " \"best_perm\": [tuple(p) for p in best_perm], # Store permutation used for MSE\n", + " \"BCE\": bce,\n", + " \"MSE\": mse,\n", + " \"combined\": total_loss\n", + "})\n", + "\n", + "def unpack_slots(selected):\n", + " \"\"\"Unpack slots showing:\n", + " - Natural order for BCE\n", + " - Permuted order for MSE visualization\n", + " \"\"\"\n", + " records = []\n", + " for _, cell in selected.iterrows():\n", + " r, c = int(cell.row), int(cell.col)\n", + " perm = cell.best_perm\n", + " \n", + " # Ground truth (always natural order)\n", + " y_t = gt_lbl[r, c] # (K,3)\n", + " \n", + " # Predictions:\n", + " p_pred = pred_lbl[r, c, :, 0] # Natural order probabilities (K,)\n", + " xy_pred = pred_lbl[r, c, :, 1:] # All coordinates (K,2)\n", + " \n", + " # Apply permutation to coordinates only\n", + " xy_pred_perm = xy_pred[list(perm)] if K > 1 else xy_pred # (K,2)\n", + " \n", + " for k in range(K):\n", + " records.append({\n", + " \"row\": r, \"col\": c, \"slot\": k,\n", + " \"GT_p\": float(y_t[k, 0]),\n", + " \"GT_x\": float(y_t[k, 1]), \n", + " \"GT_y\": float(y_t[k, 2]),\n", + " \"PR_p\": float(p_pred[k]), # Natural order probability\n", + " \"PR_x\": float(xy_pred_perm[k, 0]), # Permuted coordinates\n", + " \"PR_y\": float(xy_pred_perm[k, 1]),\n", + " # \"dist\": np.sqrt((y_t[k,1]-xy_pred_perm[k,0])**2 + (y_t[k,2]-xy_pred_perm[k,1])**2) if y_t[k,0] > 0.5 else np.nan,\n", + " \"cell_BCE\": float(cell.BCE) if k==0 else \"\",\n", + " \"cell_MSE\": float(cell.MSE) if k==0 else \"\",\n", + " \"combined\": float(cell.combined) if k==0 else \"\",\n", + " })\n", + " return pd.DataFrame(records)\n", + "\n", + "# Generate sample tables\n", + "tables = {}\n", + "for hits in (1, 2):\n", + " group = df_summary[df_summary['num_hits']==hits]\n", + " if not group.empty:\n", + " best5 = group.nsmallest(5, 'combined')\n", + " worst5 = group.nlargest(5, 'combined')\n", + " tables[f'hits={hits} BEST'] = unpack_slots(best5)\n", + " tables[f'hits={hits} WORST'] = unpack_slots(worst5)\n", + "\n", + "# Display results\n", + "for title, df in tables.items():\n", + " tools.display_dataframe_to_user(title, df)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "04b12424", + "metadata": {}, + "outputs": [], + "source": [ + "mytrue = np.array([[1,0.625, 0.5],[0,0,0]])\n", + "mypred= np.array([[0.977148,0.515033,0.51065],[0.005078,0,0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "fa6764a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1. , 0.5, 0.5],\n", + " [0. , 0. , 0. ]])" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mytrue" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "dd610acb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[9.76844e-01, 5.15033e-01, 5.10650e-01],\n", + " [2.90000e-04, 0.00000e+00, 0.00000e+00]])" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mypred" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "de6ae703", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_prob2 = tf.keras.losses.binary_crossentropy(mytrue[...,0], mypred[...,0])\n", + "loss_prob2" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "5ea044ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_coords = tf.keras.losses.MeanSquaredError()\n", + "loss_coords2 = loss_coords(mytrue[0][1:], mypred[0][1:])\n", + "loss_coords2" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "9e251f88", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAGGCAYAAACNCg6xAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVGpJREFUeJzt3XlcVNX/P/DXsIMsIqg47AqaYIKpmAsKiBIprqWpJWriRz/wccEll1wrrUyjlI+UpqRpknu5JSIqmv7cIiNzRzRkVRFZFGHu7w8/zNdxBrgDM8yor+fjwUPuueee875nLvD23nPvlQiCIICIiIiIamSg6wCIiIiInhdMnIiIiIhEYuJEREREJBITJyIiIiKRmDgRERERicTEiYiIiEgkJk5EREREIjFxIiIiIhKJiRMRERGRSEyciJ4TCxYsgEQiqZe+AgICEBAQIF8+fPgwJBIJtm7dWi/9jxo1Cm5ubvXSV20VFRVh7NixcHBwgEQiweTJk3UdEv3PjRs3IJFIEB8fLy+rz58ferExcSLSgfj4eEgkEvmXmZkZpFIpQkJC8PXXX+PBgwca6ef27dtYsGABUlNTNdKeJulzbGIsXrwY8fHxmDBhAjZs2ID33nuvyrpubm6QSCQIDg5WuX716tXyY+HMmTMK644dO4bQ0FA4OjrCzMwMLi4uCAsLw6ZNmxTqPX08Pfs1fvz4uu8wEQEAjHQdANHLbNGiRXB3d8fjx4+RnZ2Nw4cPY/LkyVi+fDl+/vlntG3bVl73ww8/xMyZM9Vq//bt21i4cCHc3Nzg6+srersDBw6o1U9tVBfb6tWrIZPJtB5DXRw6dAivv/465s+fL6q+mZkZkpOTkZ2dDQcHB4V1GzduhJmZGR4+fKhQvmXLFgwdOhS+vr6YNGkSbG1tkZ6ejqNHj2L16tUYPny4Qv1evXph5MiRSn23bNlSzb0joqowcSLSodDQUHTo0EG+PGvWLBw6dAh9+/ZFv3798Pfff8Pc3BwAYGRkBCMj7f7IlpSUwMLCAiYmJlrtpybGxsY67V+M3NxceHl5ia7ftWtXnD59GgkJCZg0aZK8/J9//kFKSgoGDhyIbdu2KWyzYMECeHl54eTJk0qfSW5urlIfLVu2xLvvvqvmntSfyuOL6HnGS3VEeiYoKAhz585FRkYGfvjhB3m5qjkaiYmJ6NatGxo2bAhLS0u0atUKs2fPBvBkXlLHjh0BAKNHj5Zftqmc9xEQEIA2bdrg7Nmz6N69OywsLOTbPjvHqVJFRQVmz54NBwcHNGjQAP369cOtW7cU6ri5uWHUqFFK2z7dZk2xqZrjVFxcjKlTp8LZ2RmmpqZo1aoVvvjiCwiCoFBPIpEgKioKO3fuRJs2bWBqagpvb2/s379f9YA/Izc3F++//z6aNm0KMzMz+Pj44Pvvv5evr5zvlZ6ejj179shjv3HjRrXtmpmZYdCgQUqX2H788UfY2toiJCREaZtr166hY8eOKhPZJk2aiNofMSqPrYsXL2LIkCGwtraGnZ0dJk2apHQWDAB++OEHtG/fHubm5mjUqBHeeecdpeOguuOrKpX9N27cGObm5mjVqhXmzJmjUCczMxNjxoxB06ZN5Z/t2rVr6z4IRCLxjBORHnrvvfcwe/ZsHDhwABERESrr/PXXX+jbty/atm2LRYsWwdTUFFevXsXx48cBAK1bt8aiRYswb948jBs3Dv7+/gCALl26yNu4c+cOQkND8c477+Ddd99F06ZNq43rk08+gUQiwQcffIDc3FzExMQgODgYqamp8jNjYoiJ7WmCIKBfv35ITk7G+++/D19fX/z666+YPn06MjMz8eWXXyrUP3bsGLZv345///vfsLKywtdff43Bgwfj5s2bsLOzqzKu0tJSBAQE4OrVq4iKioK7uzu2bNmCUaNGoaCgAJMmTULr1q2xYcMGTJkyBU5OTpg6dSoAoHHjxjXu9/Dhw9G7d29cu3YNLVq0AABs2rQJb731lsqzbK6urkhKSsI///wDJyenGtt/+PAh8vPzlcqtra1FnUUcMmQI3NzcsGTJEpw8eRJff/017t27h/Xr18vrfPLJJ5g7dy6GDBmCsWPHIi8vDytWrED37t3x+++/o2HDhvK66hxf58+fh7+/P4yNjTFu3Di4ubnh2rVr+OWXX/DJJ58AAHJycvD666/Lk+PGjRtj3759eP/991FYWMgJ+lQ/BCKqd+vWrRMACKdPn66yjo2NjdCuXTv58vz584Wnf2S//PJLAYCQl5dXZRunT58WAAjr1q1TWtejRw8BgBAXF6dyXY8ePeTLycnJAgDB0dFRKCwslJf/9NNPAgDhq6++kpe5uroK4eHhNbZZXWzh4eGCq6urfHnnzp0CAOHjjz9WqPfWW28JEolEuHr1qrwMgGBiYqJQ9scffwgAhBUrVij19bSYmBgBgPDDDz/Iy8rKyoTOnTsLlpaWCvvu6uoq9OnTp9r2nq1bXl4uODg4CB999JEgCIJw4cIFAYBw5MgRlcfEd999J9+fwMBAYe7cuUJKSopQUVGh1AeAKr9+/PHHauOrPLb69eunUP7vf/9bACD88ccfgiAIwo0bNwRDQ0Phk08+Uaj3559/CkZGRgrl1R1fqnTv3l2wsrISMjIyFMplMpn8+/fff19o1qyZkJ+fr1DnnXfeEWxsbISSkhJBEAQhPT1d6dh69ueHqLZ4qY5IT1laWlZ7d13l/+x37dpV64nUpqamGD16tOj6I0eOhJWVlXz5rbfeQrNmzbB3795a9S/W3r17YWhoiIkTJyqUT506FYIgYN++fQrlwcHB8jM6ANC2bVtYW1vj+vXrNfbj4OCAYcOGycuMjY0xceJEFBUV4ciRI3XaD0NDQwwZMgQ//vgjgCeTwp2dneVn3J41ZswY7N+/HwEBATh27Bg++ugj+Pv7w9PTE7/99ptS/f79+yMxMVHpKzAwUFR8kZGRCsv/+c9/AED++W7fvh0ymQxDhgxBfn6+/MvBwQGenp5ITk5W2F7s8ZWXl4ejR49izJgxcHFxUVhXeXlaEARs27YNYWFhEARBof+QkBDcv38f586dE7WfRHXBS3VEeqqoqKjaeSxDhw7FmjVrMHbsWMycORM9e/bEoEGD8NZbb8HAQNz/iRwdHdWaCO7p6amwLJFI4OHhUeP8nrrKyMiAVCpVSNqAJ5f8Ktc/7dk/vgBga2uLe/fu1diPp6en0vhV1U9tDB8+HF9//TX++OMPbNq0Ce+88061zxcKCQlBSEgISkpKcPbsWSQkJCAuLg59+/bFxYsXFY4RJyenKh95IMazn2+LFi1gYGAg/3yvXLkCQRCU6lV69nKj2OOrMqFt06ZNlXXy8vJQUFCAb7/9Ft9++63KOqomzBNpGhMnIj30zz//4P79+/Dw8Kiyjrm5OY4ePYrk5GTs2bMH+/fvR0JCAoKCgnDgwAEYGhrW2I8685LEqioJqKioEBWTJlTVj/DMRHJd6NSpE1q0aIHJkycjPT1d6ZECVbGwsIC/vz/8/f1hb2+PhQsXYt++fQgPD9darM9+ljKZDBKJBPv27VM5xpaWlgrLmjy+Ks+qvvvuu1Xu89OP7yDSFiZORHpow4YNAKDyTqunGRgYoGfPnujZsyeWL1+OxYsXY86cOUhOTkZwcLDGn5R85coVhWVBEHD16lWFP1i2trYoKChQ2jYjIwPNmzeXL6sTm6urKw4ePIgHDx4onHW6ePGifL0muLq64vz585DJZApnnTTdz7Bhw/Dxxx+jdevWaj1fq1LlIyyysrI0Ek+lK1euwN3dXb589epVyGQy+R2OLVq0gCAIcHd31+izoSqPi7S0tCrrNG7cGFZWVqioqKjTWTWiuuIcJyI9c+jQIXz00Udwd3fHiBEjqqx39+5dpbLKP8KPHj0CADRo0AAAVCYytbF+/XqFeVdbt25FVlYWQkND5WUtWrTAyZMnUVZWJi/bvXu30u3q6sT25ptvoqKiAitXrlQo//LLLyGRSBT6r4s333wT2dnZSEhIkJeVl5djxYoVsLS0RI8ePTTSz9ixYzF//nwsW7as2npJSUkqyyvnHLVq1Uoj8VSKjY1VWF6xYgUAyMd30KBBMDQ0xMKFC5XO3gmCgDt37tSq38aNG6N79+5Yu3Ytbt68qdQu8OQs4uDBg7Ft2zaVCVZeXl6t+iZSF884EenQvn37cPHiRZSXlyMnJweHDh1CYmIiXF1d8fPPP8PMzKzKbRctWoSjR4+iT58+cHV1RW5uLv773//CyckJ3bp1A/AkiWnYsCHi4uJgZWWFBg0aoFOnTgpnFdTRqFEjdOvWDaNHj0ZOTg5iYmLg4eGh8MiEsWPHYuvWrXjjjTcwZMgQXLt2DT/88IPCZG11YwsLC0NgYCDmzJmDGzduwMfHBwcOHMCuXbswefJkpbZra9y4cfjmm28watQonD17Fm5ubti6dSuOHz+OmJgYpTlWteXq6ooFCxbUWK9///5wd3dHWFgYWrRogeLiYhw8eBC//PILOnbsiLCwMIX6ly9fVnj2V6WmTZuiV69eNfaXnp6Ofv364Y033sCJEyfwww8/YPjw4fDx8QHw5DP7+OOPMWvWLNy4cQMDBgyAlZUV0tPTsWPHDowbNw7Tpk0TNwjP+Prrr9GtWze89tprGDduHNzd3XHjxg3s2bNH/lqeTz/9FMnJyejUqRMiIiLg5eWFu3fv4ty5czh48KDK/0wQaZyubucjeplV3npe+WViYiI4ODgIvXr1Er766iuF294rPXs7dVJSktC/f39BKpUKJiYmglQqFYYNGyZcvnxZYbtdu3YJXl5egpGRkcIt2j169BC8vb1VxlfV4wh+/PFHYdasWUKTJk0Ec3NzoU+fPkq3jwuCICxbtkxwdHQUTE1Nha5duwpnzpxRarO62J59HIEgCMKDBw+EKVOmCFKpVDA2NhY8PT2FpUuXKtyuLghPbsuPjIxUiqmqxyQ8KycnRxg9erRgb28vmJiYCK+++qrKRybU5nEE1VH1OIIff/xReOedd4QWLVoI5ubmgpmZmeDl5SXMmTNH6RhBNY8jeHbcn1V5bF24cEF46623BCsrK8HW1laIiooSSktLlepv27ZN6Natm9CgQQOhQYMGwiuvvCJERkYKly5dktep7viqSlpamjBw4EChYcOGgpmZmdCqVSth7ty5CnVycnKEyMhIwdnZWTA2NhYcHByEnj17Ct9++628Dh9HQNokEQQ9mC1JREQ6s2DBAixcuBB5eXmwt7fXdThEeo1znIiIiIhEYuJEREREJBITJyIiIiKROMeJiIiISCSecSIiIiISiYkTERERkUh8AKYWyWQy3L59G1ZWVhp/9QURERFphiAIePDgAaRSaY0vSWfipEW3b9+Gs7OzrsMgIiIiEW7dugUnJ6dq6zBx0qLK1zPcunUL1tbWOo6GiIiIVCksLISzs7Oo1yoxcdKiystz1tbWTJyIiIj0nJhpNZwcTkRERCQSEyciIiIikZg4EREREYnEOU5ERPTSk8lkKCsr03UYpCXGxsYwNDTUSFtMnIiI6KVWVlaG9PR0yGQyXYdCWtSwYUM4ODjU+bmKTJzUsHv3bkydOhUymQwffPABxo4dq+uQiIioDgRBQFZWFgwNDeHs7Fzjww/p+SMIAkpKSpCbmwsAaNasWZ3aY+IkUnl5OaKjo5GcnAwbGxu0b98eAwcOhJ2dna5DIyKiWiovL0dJSQmkUiksLCx0HQ5pibm5OQAgNzcXTZo0qdNlO6bWIp06dQre3t5wdHSEpaUlQkNDceDAAV2HRUREdVBRUQEAMDEx0XEkpG2VifHjx4/r1I5eJE6ZmZl49913YWdnB3Nzc7z66qs4c+aMxto/evQowsLCIJVKIZFIsHPnTpX1YmNj4ebmBjMzM3Tq1AmnTp2Sr7t9+zYcHR3ly46OjsjMzNRYjEREpDt8n+iLT1Ofsc4Tp3v37qFr164wNjbGvn37cOHCBSxbtgy2trYq6x8/flxltnjhwgXk5OSo3Ka4uBg+Pj6IjY2tMo6EhARER0dj/vz5OHfuHHx8fBASEiK/JkpERESk8zlOn332GZydnbFu3Tp5mbu7u8q6MpkMkZGR8PT0xObNm+XXKC9duoSgoCBER0djxowZStuFhoYiNDS02jiWL1+OiIgIjB49GgAQFxeHPXv2YO3atZg5cyakUqnCGabMzEz4+fmpvb9ERM+FgltAyZ2q11vYAQ1f3JeYZxaU4l5x/T2ewLaBCRwbmmu1jxs3bsDd3R2///47fH19VdaJj4/H5MmTUVBQoHb7ZWVl8PLywvr169GlS5e6Baumd955Bx07dsTUqVO13pfOE6eff/4ZISEhePvtt3HkyBE4Ojri3//+NyIiIpTqGhgYYO/evejevTtGjhyJDRs2ID09HUFBQRgwYIDKpEmMsrIynD17FrNmzVLoKzg4GCdOnAAA+Pn5IS0tDZmZmbCxscG+ffswd+5cle3FxsYiNjZWfu2ciOi5UnALiPUDHpdUXcfYAog89UImT5kFpQhedgSlj+vvd7i5sSEOTu2hVvIUGxuLpUuXIjs7Gz4+PlixYkWd/0M/dOhQvPnmm/LlBQsWYOfOnUhNTa1x27i4OLi7uyskTefOncMHH3yA06dPw9DQEIMHD8by5cthaWkJALhz5w5GjBiB8+fP486dO2jSpAn69++PxYsXK7zj9fDhw4iOjsZff/0FZ2dnfPjhhxg1apR8/Ycffoju3btj7NixsLGxqdMY1ETnidP169exatUqREdHY/bs2Th9+jQmTpwIExMThIeHK9WXSqU4dOgQ/P39MXz4cJw4cQLBwcFYtWpVrWPIz89HRUUFmjZtqlDetGlTXLx4EQBgZGSEZcuWITAwEDKZDDNmzKjyjrrIyEhERkaisLBQ6x8gEZHGldx5kjQNWg3Yt1Ren38Z2B7xpN4LmDjdKy5D6eMKxAz1hUcTS633dzW3CJMTUnGvuEx04lQ5vSQuLg6dOnVCTEwMQkJCcOnSJTRp0qTWsZibm8vvQFOHIAhYuXIlFi1aJC+7ffs2goODMXToUKxcuRKFhYWYPHkyRo0aha1btwJ4cpKif//++Pjjj9G4cWNcvXoVkZGRuHv3LjZt2gQASE9PR58+fTB+/Hhs3LgRSUlJGDt2LJo1a4aQkBAAQJs2bdCiRQv88MMPiIyMrPX+i91ZnTI2NhY6d+6sUPaf//xHeP3116vd7siRIwIAoXnz5sLjx49F9wdA2LFjh0JZZmamAED47bffFMqnT58u+Pn5iW77Wffv3xcACPfv3691G0RE9S7zd0GYb/3k39qsf46UlpYKFy5cEEpLS+Vlf/5TILh+sFv485+CeomhNv35+fkJkZGR8uWKigpBKpUKS5YsqXKb9PR0AYCwbds2ISAgQDA3Nxfatm2r8Ldv3bp1go2Njfx7AApf69atU9n26dOnBQMDA6GwsFBe9s033whNmjQRKioq5GXnz58XAAhXrlypMs6vvvpKcHJyki/PmDFD8Pb2VqgzdOhQISQkRKFs4cKFQrdu3apsV9VnXUmdv9c6nxzerFkzeHl5KZS1bt0aN2/erHKbnJwcjBs3DmFhYSgpKcGUKVPqFIO9vT0MDQ2VJpfn5OTAwcGhTm0TERFpUuX0kuDgYHnZs9NLqjNnzhxMmzYNqampaNmyJYYNG4by8nKlekOHDsXUqVPh7e2NrKwsZGVlYejQoSrbTElJQcuWLWFlZSUve/ToEUxMTBQeKlp5NuvYsWMq27l9+za2b9+OHj16yMsqryw9LSQkRGlf/fz8cOrUKTx69KiGEagbnSdOXbt2xaVLlxTKLl++DFdXV5X18/Pz0bNnT7Ru3Rrbt29HUlISEhISMG3atFrHYGJigvbt2yMpKUleJpPJkJSUhM6dO9e6XSIiIk2rbnpJdnZ2jdtPmzYNffr0QcuWLbFw4UJkZGTg6tWrSvXMzc1haWkJIyMjODg4wMHBocrLeBkZGZBKpQplQUFByM7OxtKlS1FWVoZ79+5h5syZAICsrCyFusOGDYOFhQUcHR1hbW2NNWvWyNdlZ2er3NfCwkKUlpbKy6RSKcrKykSNQV3oPHGaMmUKTp48icWLF+Pq1avYtGkTvv32W5XXKGUyGUJDQ+Hq6oqEhAQYGRnBy8sLiYmJWLduHb788kuVfRQVFSE1NVU+uS09PR2pqakKZ7Wio6OxevVqfP/99/j7778xYcIEFBcXy++yIyIiel6MHz8elpaW8q+ntW3bVv595etH6vrondLSUpiZmSmUeXt74/vvv8eyZctgYWEBBwcHuLu7o2nTpkqvtvnyyy9x7tw57Nq1C9euXUN0dLTaMVQmdSUl1dzUoAE6nxzesWNH7NixA7NmzcKiRYvg7u6OmJgYjBgxQqmugYEBFi9eDH9/f4WnvPr4+ODgwYNo3Lixyj7OnDmDwMBA+XLlBxIeHo74+HgAT05J5uXlYd68ecjOzoavry/279+vlOUSERHpkpjpJYsWLarySoyxsbH8+8qHQtb1Bcf29vb4888/lcqHDx+O4cOHIycnBw0aNIBEIsHy5cvRvHlzhXqVZ7ReeeUVNGrUCP7+/pg7dy6aNWsGBwcHlftqbW2tcAbs7t27AFBlLqApOk+cAKBv377o27evqLq9evVSWd6uXbsqtwkICIAgCDW2HRUVhaioKFFxEBER6cLT00sGDBgA4P+ml1T+DWvSpEmd7q57ui8xj9Zp164dVq1aBUEQVD6hu/IkxNq1a2FmZlbl33Lg/5K4yrlKnTt3xt69exXqJCYmKk2lSUtLg5OTE+zt7WuMty70InEiIiIi8aKjoxEeHo4OHTrAz88PMTExWple4ubmJp/e4uTkBCsrK5iamirVCwwMRFFREf766y+0adNGXr5y5Up06dIFlpaWSExMxPTp0/Hpp5+iYcOGAIC9e/ciJycHHTt2hKWlJf766y9Mnz4dXbt2hZubG4Anlx1XrlyJGTNmYMyYMTh06BB++ukn7NmzRyGGlJQU9O7dW6P7rwoTJyIiIhWu5hbpbT/1Nb1k8ODB2L59OwIDA1FQUIB169YpPHiykp2dHQYOHIiNGzdiyZIl8vJTp05h/vz5KCoqwiuvvIJvvvkG7733nny9ubk5Vq9ejSlTpuDRo0dwdnbGoEGD5JPIgSdvE9mzZw+mTJmCr776Ck5OTlizZo38GU4A8PDhQ+zcuRP79+/X6P6rIhHEXMOiWql8AOb9+/cVnoBKRKTXbqcC3/YAxh0BpL7qr3+OPHz4EOnp6XB3d5dPbn5enhyub86fP49evXrh2rVrShPStW3VqlXYsWMHDhw4UGUdVZ91JXX+XvOMExER0VMcG5rj4NQeL9y76rStbdu2+Oyzz5Ceno5XX321Xvs2NjbGihUr6qUvJk5ERETPcGxo/twnMrqg6jJefRg7dmy99aXz5zgRERERPS+YOBERERGJxMSJiIiISCQmTkREREQiMXEiIiIiEomJExEREZFITJyIiIiIROJznIiIiJ5VcAsouVN//VnYAQ2dtd6NRCLBjh075C8Hftbhw4cRGBiIe/fuyd8np47u3btj/PjxGD58eN0CfcqFCxfQu3dvXLp0CQ0aNNBYu7XFxImIiOhpBbeAWD/gcUn99WlsAUSeEp08HT16FEuXLsXZs2eRlZVVbTKkji5duiArKws2NjYAgPj4eEyePBkFBQU1bvvzzz8jJycH77zzjrwsOzsb06dPR2JiIh48eIBWrVphzpw5GDx4sLzO5cuXMX36dBw/fhxlZWVo27YtPvroIwQGBgIAvLy88Prrr2P58uWYO3dunfexrpg4ERERPa3kzpOkadBqwL6l9vvLvwxsj3jSr8jEqbi4GD4+PhgzZgwGDRqksVBMTEzg4OBQq22//vprjB49GgYG/zcLaOTIkSgoKMDPP/8Me3t7bNq0CUOGDMGZM2fQrl07AEDfvn3h6emJQ4cOwdzcHDExMejbty+uXbsmj2X06NGIiIjArFmzYGSk49RFIK25f/++AEC4f/++rkMhIhIv83dBmG/95N/arH+OlJaWChcuXBBKS0v/r7C+96+O/QEQduzYIbru6tWrhQEDBgjm5uaCh4eHsGvXLvn65ORkAYBw7949+fdPf82fP19lu7m5uYJEIhHS0tIUyhs0aCCsX79eoaxRo0bC6tWrBUEQhLy8PAGAcPToUfn6wsJCAYCQmJgoL3v06JFgamoqHDx4UNR+qqLys/4fdf5ec3I4ERHRS2ThwoUYMmQIzp8/jzfffBMjRozA3bt3lep16dIFMTExsLa2RlZWFrKysjBt2jSVbR47dgwWFhZo3bq1UhsJCQm4e/cuZDIZNm/ejIcPHyIgIAAAYGdnh1atWmH9+vUoLi5GeXk5vvnmGzRp0gTt27eXt2NiYgJfX1+kpKRobiBqiYkTERHRS2TUqFEYNmwYPDw8sHjxYhQVFeHUqVNK9UxMTGBjYwOJRAIHBwc4ODjA0tJSZZsZGRlo2rSpwmU6APjpp5/w+PFj2NnZwdTUFP/617+wY8cOeHh4AHgyWf3gwYP4/fffYWVlBTMzMyxfvhz79++Hra2tQltSqRQZGRkaGoXaY+JERET0glm8eDEsLS3lXzdv3pSva9u2rfz7Bg0awNraGrm5uXXqr7S0FGZmZkrlc+fORUFBAQ4ePIgzZ84gOjoaQ4YMwZ9//gkAEAQBkZGRaNKkCVJSUnDq1CkMGDAAYWFhyMrKUmjL3NwcJSX1OGG/CpwcTkREmlXTrfzV3Xpfl21Jbvz48RgyZIh8WSqVyr83NjZWqCuRSCCTyerUn729Pe7du6dQdu3aNaxcuRJpaWnw9vYGAPj4+CAlJQWxsbGIi4vDoUOHsHv3bty7dw/W1tYAgP/+979ITEzE999/j5kzZ8rbu3v3Llq0aFGnODWBiZMWxMbGIjY2FhUVFboOhYiofom5lb+qW+/rsi0paNSoERo1alTndkxMTET9LWvXrh2ys7Nx7949+SW2yrNDz16+MzQ0lCdqVdUxMDBQSubS0tLw1ltv1W5HNIiJkxZERkYiMjIShYWF8mdhEBG9FGq6lb+6W+/rsu1LpqioCFevXpUvp6enIzU1FY0aNYKLi4vG+nFzc0NRURGSkpLg4+MDCwsLWFhYKNVr164d7O3tcfz4cfTt2xcA8Morr8DDwwP/+te/8MUXX8DOzg47d+5EYmIidu/eDQDo3LkzbG1tER4ejnnz5sHc3ByrV69Geno6+vTpI2//xo0byMzMRHBwsMb2rbaYOBERkebZtwSkvvW/rSblX9bbfs6cOSN/QCQAREdHAwDCw8MRHx+vqcjQpUsXjB8/HkOHDsWdO3cwf/58LFiwQKmeoaEhRo8ejY0bN8oTJ2NjY+zduxczZ85EWFgYioqK4OHhge+//x5vvvkmgCeX+Pbv3485c+YgKCgIjx8/hre3N3bt2gUfHx95+z/++CN69+4NV1dXje1bbTFxIiIiepqF3ZNLgtsj6q9PY4sn/YoUEBAAQRDU7kbVNk8/FVxVu6tWrcKqVatqbHvKlCnw9vZGRkaGPMHx9PTEtm3bqt2uQ4cO+PXXX6tcX1ZWhri4OGzatKnGGOoDEyciIqKnNXR+Mo/qBXxXnTY5ODjgu+++w82bNzV6ZujmzZuYPXs2unbtqrE264KJExER0bMaOj/3iYwuaOJ9ec/y8PCQP/dJH/A5TkREREQiMXEiIiIiEomJExEREZFITJyIiIiIRGLiRERERCQSEyciIiIikZg4EREREYnE5zgRERE9I6soC/ce3au3/mxNbdHMsplW+7hx4wbc3d3x+++/w9fXV2Wd+Ph4TJ48WeFp4mKVlZXBy8sL69evR5cuXURtc+HCBfTu3RuXLl1CgwYN1O5TF5g4ERERPSWrKAv9d/VHaXlpvfVpbmSOXf13iU6elixZgu3bt+PixYswNzdHly5d8Nlnn6FVq1Z1imPo0KHy98gBwIIFC7Bz506kpqbWuG1cXBzc3d2VkqY9e/Zg0aJFOH/+PMzMzNCjRw/s3LkTAODl5YXXX38dy5cvx9y5c+sUe31h4kRERPSUe4/uobS8FEv8l6C5TXOt93f9/nXMSpmFe4/uiU6cjhw5gsjISHTs2BHl5eWYPXs2evfujQsXLtTpzI25uTnMzc3V3k4QBKxcuRKLFi1SKN+2bRsiIiKwePFiBAUFoby8HGlpaQp1Ro8ejYiICMyaNQtGRvqfluh/hERERDrQ3KY5vOy8dB2GSvv371dYjo+PR5MmTXD27Fl079692m2vX7+OKVOm4P/9v/8HT09PxMXFoXPnzvJ2Ki/VxcfHY+HChQAAiUQCAFi3bh1GjRql1ObZs2dx7do19OnTR15WXl6OSZMmYenSpXj//ffl5V5eimPaq1cv3L17F0eOHEHPnj3FD4KOcHI4ERHRc+7+/fsAgEaNGtVYd86cOZg2bRpSU1PRsmVLDBs2DOXl5Ur1hg4diqlTp8Lb2xtZWVnIysrC0KFDVbaZkpKCli1bwsrKSl527tw5ZGZmwsDAAO3atUOzZs0QGhqqdMbJxMQEvr6+SElJUWeXdYaJExER0XNMJpNh8uTJ6Nq1K9q0aVNj/WnTpqFPnz5o2bIlFi5ciIyMDFy9elWpnrm5OSwtLWFkZAQHBwc4ODhUeRkvIyMDUqlUoez69esAnsyT+vDDD7F7927Y2toiICAAd+/eVagrlUqRkZEhdpd1iokTERHRcywyMhJpaWnYvHmzvGz8+PGwtLSUfz2tbdu28u+bNXsypyo3N7dOMZSWlsLMzEyhTCaTAXhyhmvw4MFo37491q1bB4lEgi1btijUNTc3R0lJSZ1iqC9MnIiIiJ5TUVFR2L17N5KTk+Hk5CQvX7RoEVJTU+VfTzM2NpZ/Xzl3qTLJqS17e3vcu6f4+IbKpOzpOU2mpqZo3rw5bt68qVD37t27aNy4cZ1iqC9MnIiIiJ4zgiAgKioKO3bswKFDh+Du7q6wvkmTJvDw8JB/1ZaJiQkqKipqrNeuXTtcvHgRgiDIy9q3bw9TU1NcunRJXvb48WPcuHEDrq6uCtunpaWhXbt2tY6zPjFxIiIies5ERkbihx9+wKZNm2BlZYXs7GxkZ2ejtFSzz55yc3NDeno6UlNTkZ+fj0ePHqmsFxgYiKKiIvz111/yMmtra4wfPx7z58/HgQMHcOnSJUyYMAEA8Pbbb8vr3bhxA5mZmQgODtZo7NrCxxEQERGpcP3+db3tZ9WqVQCAgIAAhfKqHhdQW4MHD8b27dsRGBiIgoKCKtu3s7PDwIEDsXHjRixZskRevnTpUhgZGeG9995DaWkpOnXqhEOHDsHW1lZe58cff0Tv3r2VzkLpKyZORERET7E1tYW5kTlmpcyqtz7Njcxha2pbc8X/efqSmFhubm5K2zVs2FChbNSoUQqJkampKbZu3Sqq/Tlz5qBXr16YM2eOfEK6sbExvvjiC3zxxRcqtykrK0NcXBw2bdqk5t7oDhMnIiKipzSzbIZd/Xe9cO+q07a2bdvis88+Q3p6Ol599VVR29y8eROzZ89G165dtRyd5jBxIiIiekYzy2bPfSKjC+peJqzr5HVd4ORwNezevRutWrWCp6cn1qxZo+twiIiIqJ7xjJNI5eXliI6ORnJyMmxsbNC+fXsMHDgQdnZ2ug6NiIiI6gnPOIl06tQpeHt7w9HREZaWlggNDcWBAwd0HRYRERHVI71KnD799FNIJBJMnjxZo+0ePXoUYWFhkEqlkEgk2Llzp8p6sbGxcHNzg5mZGTp16oRTp07J192+fRuOjo7yZUdHR2RmZmo0TiIi0o3a3KVGz5e6Ph29kt5cqjt9+jS++eYbhXfoqHL8+HH4+fkpPDIeAC5cuAA7Ozs0bdpUaZvi4mL4+PhgzJgxGDRokMp2ExISEB0djbi4OHTq1AkxMTEICQnBpUuX0KRJk9rvGBER6S1jY2NIJBLk5eWhcePG8leQ0ItDEASUlZUhLy8PBgYGMDExqVN7epE4FRUVYcSIEVi9ejU+/vjjKuvJZDJERkbC09MTmzdvhqGhIQDg0qVLCAoKQnR0NGbMmKG0XWhoKEJDQ6uNYfny5YiIiMDo0aMBAHFxcdizZw/Wrl2LmTNnQiqVKpxhyszMhJ+fX212l4iI9IShoSGcnJzwzz//4MaNG7oOh7TIwsICLi4uMDCo28U2vUicIiMj0adPHwQHB1ebOBkYGGDv3r3o3r07Ro4ciQ0bNiA9PR1BQUEYMGCAyqRJjLKyMpw9exazZv3fw84MDAwQHByMEydOAAD8/PyQlpaGzMxM2NjYYN++fZg7d26t+qOXTMEtoOSO6nUWdkBDZ823q89ta5O2xvp5xfEQxdLSEp6ennj8+LGuQyEtMTQ0hJGRkUbOKOo8cdq8eTPOnTuH06dPi6ovlUpx6NAh+Pv7Y/jw4Thx4gSCg4Plj5+vjfz8fFRUVChd5mvatCkuXrwIADAyMsKyZcsQGBgImUyGGTNmVHlHXWxsLGJjY0W9GJFecAW3gFg/4HGJ6vXGFkDkKfX/gNXUrr62rU3aGuvnFcdDLYaGhvKrGETV0WnidOvWLUyaNAmJiYkwMzMTvZ2Liws2bNiAHj16oHnz5vjuu+/q5bp0v3790K9fvxrrRUZGIjIyEoWFhbCxsdF6XKTHSu48+cM1aDVg31JxXf5lYHvEkzrq/vGqrl19blubtDXWzyuOB5FW6DRxOnv2LHJzc/Haa6/JyyoqKnD06FGsXLkSjx49Uvk/gJycHIwbNw5hYWE4ffo0pkyZghUrVtQ6Dnt7exgaGiInJ0epHwcHh1q3SyRn3xKQ+j4/7Wq7bW16XuPWFo4HkUbp9HEEPXv2xJ9//onU1FT5V4cOHTBixAikpqaqTJry8/PRs2dPtG7dGtu3b0dSUhISEhIwbdq0WsdhYmKC9u3bIykpSV4mk8mQlJSEzp0717pdIiIierHo9IyTlZUV2rRpo1DWoEED2NnZKZUDT5KZ0NBQuLq6IiEhAUZGRvDy8kJiYiKCgoLg6OiIKVOmKG1XVFSEq1evypfT09ORmpqKRo0awcXFBQAQHR2N8PBwdOjQAX5+foiJiUFxcbH8LjsiIiIinU8OV4eBgQEWL14Mf39/hecw+Pj44ODBg2jcuLHK7c6cOYPAwED5cnR0NAAgPDwc8fHxAIChQ4ciLy8P8+bNQ3Z2Nnx9fbF//36Vz4UiIiKil5PeJU6HDx+udn2vXr1Ulrdr167KbQICAkQ9FTYqKgpRUVE11iMiIqKXk169coWIiIhInzFxIiIiIhKJiRMRERGRSEyciIiIiERi4kREREQkEhMnIiIiIpGYOBERERGJxMSJiIiISCQmTkREREQiqfXk8L///hubN29GSkoKMjIyUFJSgsaNG6Ndu3YICQnB4MGDYWpqqq1YiYiIiHRK1Bmnc+fOITg4GO3atcOxY8fQqVMnTJ48GR999BHeffddCIKAOXPmQCqV4rPPPsOjR4+0HTcRERFRvRN1xmnw4MGYPn06tm7dioYNG1ZZ78SJE/jqq6+wbNkyzJ49W1MxEhEREekFUYnT5cuXYWxsXGO9zp07o3Pnznj8+HGdAyMiIiLSN6Iu1VWVND18+FCt+kRERETPM7XvqpPJZPjoo4/g6OgIS0tLXL9+HQAwd+5cfPfddxoPkIiIiEhfqJ04ffzxx4iPj8fnn38OExMTeXmbNm2wZs0ajQZHREREpE/UTpzWr1+Pb7/9FiNGjIChoaG83MfHBxcvXtRocERERET6RO3EKTMzEx4eHkrlMpmMk8KJiIjohaZ24uTl5YWUlBSl8q1bt6Jdu3YaCYqIiIhIH6n15HAAmDdvHsLDw5GZmQmZTIbt27fj0qVLWL9+PXbv3q2NGImIiIj0gtpnnPr3749ffvkFBw8eRIMGDTBv3jz8/fff+OWXX9CrVy9txEhERESkF9Q+4wQA/v7+SExM1HQsRERERHpN7TNORERERC8rUWecbG1tIZFIRDV49+7dOgVEREREpK9EJU4xMTFaDoOIiIhI/4lKnMLDw7UdBxEREZHeq9Xk8EoPHz5EWVmZQpm1tXWdAiIiIiLSV2pPDi8uLkZUVBSaNGmCBg0awNbWVuGLiIiI6EWlduI0Y8YMHDp0CKtWrYKpqSnWrFmDhQsXQiqVYv369dqIkYiIiEgvqH2p7pdffsH69esREBCA0aNHw9/fHx4eHnB1dcXGjRsxYsQIbcRJREREpHNqn3G6e/cumjdvDuDJfKbKxw9069YNR48e1Wx0emb37t1o1aoVPD09sWbNGl2HQ0RERPVM7cSpefPmSE9PBwC88sor+OmnnwA8ORPVsGFDjQanT8rLyxEdHY1Dhw7h999/x9KlS3Hnzh1dh0VERET1SO3EafTo0fjjjz8AADNnzkRsbCzMzMwwZcoUTJ8+XeMB6otTp07B29sbjo6OsLS0RGhoKA4cOKDrsIiIiKgeqZ04TZkyBRMnTgQABAcH4+LFi9i0aRN+//13TJo0Se0AVq1ahbZt28La2hrW1tbo3Lkz9u3bp3Y71Tl69CjCwsIglUohkUiwc+dOlfViY2Ph5uYGMzMzdOrUCadOnZKvu337NhwdHeXLjo6OyMzM1GicREREpN/q/K46V1dXDBo0CG3btq3V9k5OTvj0009x9uxZnDlzBkFBQejfvz/++usvlfWPHz+Ox48fK5VfuHABOTk5KrcpLi6Gj48PYmNjq4wjISEB0dHRmD9/Ps6dOwcfHx+EhIQgNze3VvtFRERELx6176qbOHEiPDw85GedKq1cuRJXr15V+/UsYWFhCsuffPIJVq1ahZMnT8Lb21thnUwmQ2RkJDw9PbF582YYGhoCAC5duoSgoCBER0djxowZSn2EhoYiNDS02jiWL1+OiIgIjB49GgAQFxeHPXv2YO3atZg5cyakUqnCGabMzEz4+fmpta9EBKDgFlBSxfxACzugoXP9xiNGdTHXpK77pM3xyr+sXjkRqZ84bdu2DT///LNSeZcuXfDpp5/W6b12FRUV2LJlC4qLi9G5c2el9QYGBti7dy+6d++OkSNHYsOGDUhPT0dQUBAGDBigMmkSo6ysDGfPnsWsWbMU+goODsaJEycAAH5+fkhLS0NmZiZsbGywb98+zJ07V2V7sbGxiI2NRUVFRa3iIXphFdwCYv2AxyWq1xtbAJGn9Ct5qinmmtRln7Q1XhZ2T7bdHlF1HWOLJ/WISIHaidOdO3dgY2OjVG5tbY38/PxaBfHnn3+ic+fOePjwISwtLbFjxw54eXmprCuVSnHo0CH4+/tj+PDhOHHiBIKDg7Fq1apa9Q0A+fn5qKioQNOmTRXKmzZtiosXLwIAjIyMsGzZMgQGBkImk2HGjBmws1P9SyUyMhKRkZEoLCxUOVZEL62SO0+SgEGrAfuWiuvyLz/5Q15yR78Sp+pirkld90lb49XQ+UnCVd1ZNH09+0ekY2onTh4eHti/fz+ioqIUyvft2yd/vpO6WrVqhdTUVNy/fx9bt25FeHg4jhw5UmXy5OLigg0bNqBHjx5o3rw5vvvuO0gkklr1rY5+/fqhX79+Wu+H6IVn3xKQ+uo6CvXoMmZt9N3QmYkRUS2onThFR0cjKioKeXl5CAoKAgAkJSVh2bJltb5MZ2JiAg8PDwBA+/btcfr0aXz11Vf45ptvVNbPycnBuHHjEBYWhtOnT2PKlClYsWJFrfoGAHt7exgaGipNLs/JyYGDg0Ot2yUiIqIXi9qJ05gxY/Do0SN88skn+OijjwAAbm5uWLVqFUaOHKmRoGQyGR49eqRyXX5+Pnr27InWrVtjy5YtuHz5MgICAmBqaoovvviiVv2ZmJigffv2SEpKwoABA+QxJCUlKZ1ZIyIiopeX2okTAEyYMAETJkxAXl4ezM3NYWlpWesAZs2ahdDQULi4uODBgwfYtGkTDh8+jF9//VWprkwmQ2hoKFxdXZGQkAAjIyN4eXkhMTERQUFBcHR0xJQpU5S2KyoqwtWrV+XL6enpSE1NRaNGjeDi4gLgyZm08PBwdOjQAX5+foiJiUFxcbH8LjsiIiIitROn0tJSCIIACwsLNG7cGBkZGVizZg28vLzQu3dvtQPIzc3FyJEjkZWVBRsbG7Rt2xa//vorevXqpVTXwMAAixcvhr+/P0xMTOTlPj4+OHjwIBo3bqyyjzNnziAwMFC+HB0dDQAIDw9HfHw8AGDo0KHIy8vDvHnzkJ2dDV9fX+zfv19pwjgRERG9vNROnPr3749BgwZh/PjxKCgogJ+fH0xMTJCfn4/ly5djwoQJarX33XffqVVfVUIFAO3atatym4CAAAiCUGPbUVFRvDRHREREVVL7yeHnzp2Dv78/AGDr1q1wcHBARkYG1q9fj6+//lrjARIRERHpC7UTp5KSElhZWQEADhw4gEGDBsHAwACvv/46MjIyNB4gERERkb5QO3Hy8PDAzp07cevWLfz666/yeU25ubmwtrbWeIBERERE+kLtxGnevHmYNm0a3Nzc0KlTJ/mrUQ4cOFDtPCMiIiKi553ak8PfeustdOvWDVlZWfDx8ZGX9+zZEwMHDtRocERERET6pFbPcXJwcFB6orafn59GAiIiIiLSV2pfqiMiIiJ6WTFxIiIiIhKJiRMRERGRSEyciIiIiERSe3L4zz//rLJcIpHAzMwMHh4ecHd3r3NgRERERPpG7cRpwIABkEgkSu9+qyyTSCTo1q0bdu7cCVtbW40FSkRERKRral+qS0xMRMeOHZGYmIj79+/j/v37SExMRKdOnbB7924cPXoUd+7cwbRp07QRLxEREZHOqH3GadKkSfj222/RpUsXeVnPnj1hZmaGcePG4a+//kJMTAzGjBmj0UCJiIiIdE3tM07Xrl1T+U46a2trXL9+HQDg6emJ/Pz8ukdHREREpEfUTpzat2+P6dOnIy8vT16Wl5eHGTNmoGPHjgCAK1euwNnZWXNREhEREekBtS/Vfffdd+jfvz+cnJzkydGtW7fQvHlz7Nq1CwBQVFSEDz/8ULOREhEREemY2olTq1atcOHCBRw4cACXL1+Wl/Xq1QsGBk9OYA0YMECjQRIRERHpg1q95NfAwABvvPEG3njjDU3HQ0RERKS3avXk8CNHjiAsLAweHh7w8PBAv379kJKSounYiIiIiPSK2onTDz/8gODgYFhYWGDixImYOHEizMzM0LNnT2zatEkbMRIRERHpBbUv1X3yySf4/PPPMWXKFHnZxIkTsXz5cnz00UcYPny4RgMkIiIi0hdqn3G6fv06wsLClMr79euH9PR0jQRFREREpI/UTpycnZ2RlJSkVH7w4EE+u4mIiIheaGpfqps6dSomTpyI1NRU+WtXjh8/jvj4eHz11VcaD5CIiIhIX6idOE2YMAEODg5YtmwZfvrpJwBA69atkZCQgP79+2s8QCIiIiJ9UavnOA0cOBADBw7UdCxEREREeq1Wz3EiIiIiehmJOuNka2sLiUQiqsG7d+/WKSAiIiIifSUqcYqJidFyGERERET6T1TiFB4eru04iIiIiPSeqDlOxcXFajWqbn0iIiKi54GoxMnDwwOffvopsrKyqqwjCAISExMRGhqKr7/+WmMBEhEREekLUZfqDh8+jNmzZ2PBggXw8fFBhw4dIJVKYWZmhnv37uHChQs4ceIEjIyMMGvWLPzrX//SdtxERERE9U5U4tSqVSts27YNN2/exJYtW5CSkoLffvsNpaWlsLe3R7t27bB69WqEhobC0NBQ2zETERER6YRaD8B0cXHB1KlTMXXqVG3FQ0RERKS3+ABMIiIiIpGYOBERERGJxMSJiIiISCQmTkREREQiMXEiIiIiEomJExEREZFITJyIiIiIRGLiRERERCQSEyciIiIikdROnIKCglBQUKBUXlhYiKCgIE3ERERERKSX1E6cDh8+jLKyMqXyhw8fIiUlRSNBEREREekj0e+qO3/+vPz7CxcuIDs7W75cUVGB/fv3w9HRUbPREREREekR0YmTr68vJBIJJBKJykty5ubmWLFihUaD0ze7d+/G1KlTIZPJ8MEHH2Ds2LG6DomIiIjqkejEKT09HYIgoHnz5jh16hQaN24sX2diYoImTZrA0NBQK0Hqg/LyckRHRyM5ORk2NjZo3749Bg4cCDs7O12HRkRERPVEdOLk6uoKAJDJZFoLRp+dOnUK3t7e8suRoaGhOHDgAIYNG6bjyIiIiKi+iE6cnnblyhUkJycjNzdXKZGaN2+eWm0tWbIE27dvx8WLF2Fubo4uXbrgs88+Q6tWrWoTmkpHjx7F0qVLcfbsWWRlZWHHjh0YMGCAUr3Y2FgsXboU2dnZ8PHxwYoVK+Dn5wcAuH37tsIcLkdHR2RmZmosRiIiItJ/at9Vt3r1arRu3Rrz5s3D1q1bsWPHDvnXzp071Q7gyJEjiIyMxMmTJ5GYmIjHjx+jd+/eKC4uVln/+PHjePz4sVL5hQsXkJOTo3Kb4uJi+Pj4IDY2tso4EhISEB0djfnz5+PcuXPw8fFBSEgIcnNz1d4nIiIiejGpfcbp448/xieffIIPPvhAIwHs379fYTk+Ph5NmjTB2bNn0b17d4V1MpkMkZGR8PT0xObNm+Vzqi5duoSgoCBER0djxowZSn2EhoYiNDS02jiWL1+OiIgIjB49GgAQFxeHPXv2YO3atZg5cyakUqnCGabMzEz52Sh6wRXcAkru1G7b/Mt1q2NhBzR0rl3fNalqv8TEXJt2NdF2XelqrKujz+NVE1XxiY25Ltu+aKo7BnR1XFKV1E6c7t27h7ffflsbsQAA7t+/DwBo1KiR0joDAwPs3bsX3bt3x8iRI7Fhwwakp6cjKCgIAwYMUJk0iVFWVoazZ89i1qxZCn0FBwfjxIkTAAA/Pz+kpaUhMzMTNjY22LdvH+bOnauyvdjYWMTGxqKioqJW8ZAeKbgFxPoBj0tq34axxZNffs+ysHuybntE9dtGntL8L86a9quqmOvabl3argtdjnV19HW8alLTeFYXc122fRGJ+Vms7+OSqqV24vT222/jwIEDGD9+vMaDkclkmDx5Mrp27Yo2bdqorCOVSnHo0CH4+/tj+PDhOHHiBIKDg7Fq1apa95ufn4+Kigo0bdpUobxp06a4ePEiAMDIyAjLli1DYGAgZDIZZsyYUeUddZGRkYiMjERhYSFsbGxqHRfpgZI7T36hDVoN2LesXRtV/Y+xofOTX4jVnW3YHvFkvaZ/ada0X7X9X66Y8dLF/6B1OdbV0dfxqklN41ldzHXZ9kVU3TGgq+OSqqV24uTh4YG5c+fi5MmTePXVV2FsbKywfuLEibUOJjIyEmlpaTh27Fi19VxcXLBhwwb06NEDzZs3x3fffQeJRFLrfsXq168f+vXrp/V+SA/ZtwSkvppvt6Gzbn8hamu/tNVuXeh6rKujj+NVk7qMpz5/FrryPB4DLym1E6dvv/0WlpaWOHLkCI4cOaKwTiKR1DpxioqKwu7du3H06FE4OTlVWzcnJwfjxo1DWFgYTp8+jSlTptTp4Zv29vYwNDRUmlyek5MDBweHWrdLRERELxa1E6f09HSNBiAIAv7zn/9gx44dOHz4MNzd3autn5+fj549e6J169bYsmULLl++jICAAJiamuKLL76oVQwmJiZo3749kpKS5I8pkMlkSEpKQlRUVK3aJCIiohdPrZ7jpEmRkZHYtGkTdu3aBSsrK/k78GxsbGBubq5QVyaTITQ0FK6urkhISICRkRG8vLyQmJiIoKAgODo6YsqUKUp9FBUV4erVq/Ll9PR0pKamolGjRnBxcQEAREdHIzw8HB06dICfnx9iYmJQXFwsv8uOiIiISO3EacyYMdWuX7t2rVrtVU7qDggIUChft24dRo0apVBmYGCAxYsXw9/fHyYmJvJyHx8fHDx4UOE1ME87c+YMAgMD5cvR0dEAgPDwcMTHxwMAhg4diry8PMybNw/Z2dnw9fXF/v37lSaMExER0curVo8jeNrjx4+RlpaGgoIClS//rYkgCGrV79Wrl8rydu3aVblNQECAqH6ioqJ4aY6IiIiqpHbitGPHDqUymUyGCRMmoEWLFhoJioiIiEgfqf3KFZWNGBggOjoaX375pSaaIyIiItJLGkmcAODatWsoLy/XVHNEREREekftS3WVE6srCYKArKws7NmzB+Hh4RoLjIiIiEjfqJ04/f777wrLBgYGaNy4MZYtW1bjHXdEREREzzO1E6fk5GRtxEFERESk92r9AMy8vDxcunQJANCqVasqn6FERERE9KJQe3J4cXExxowZg2bNmqF79+7o3r07pFIp3n//fZSUlGgjRiIiIiK9oHbiFB0djSNHjuCXX35BQUEBCgoKsGvXLhw5cgRTp07VRoxEREREekHtS3Xbtm3D1q1bFV6R8uabb8Lc3BxDhgyRv0KFiIiI6EWj9hmnkpISle9va9KkCS/VERER0QtN7cSpc+fOmD9/Ph4+fCgvKy0txcKFC9G5c2eNBkdERESkT9S+VPfVV18hJCQETk5O8PHxAQD88ccfMDMzw6+//qrxAImIiIj0hdqJU5s2bXDlyhVs3LgRFy9eBAAMGzYMI0aMgLm5ucYDJCIiItIXtXqOk4WFBSIiIjQdCxEREZFeU3uO05IlS7B27Vql8rVr1+Kzzz7TSFBERERE+kjtxOmbb77BK6+8olTu7e2NuLg4jQRFREREpI/UTpyys7PRrFkzpfLGjRsjKytLI0ERERER6SO1EydnZ2ccP35cqfz48eOQSqUaCYqIiIhIH6k9OTwiIgKTJ0/G48ePERQUBABISkrCjBkz+MoVIiIieqGpnThNnz4dd+7cwb///W+UlZUBAMzMzPDBBx9g1qxZGg+QiIiISF+onThJJBJ89tlnmDt3Lv7++2+Ym5vD09MTpqam2oiPiIiISG/U6jlOAGBpaYmOHTtqMhYiIiIivab25HAiIiKilxUTJyIiIiKRmDgRERERicTEiYiIiEgkJk5EREREIjFxIiIiIhKJiRMRERGRSEyciIiIiERi4kREREQkEhMnIiIiIpGYOBERERGJxMSJiIiISCQmTkREREQiMXEiIiIiEomJExEREZFITJyIiIiIRGLiRERERCQSEyciIiIikZg4EREREYnExImIiIhIJCZORERERCIxcSIiIiISiYkTERERkUhMnIiIiIhEYuJEREREJBITJyIiIiKRmDgRERERicTEiYiIiEgkJk5EREREIjFxIiIiIhKJiRMRERGRSEyciIiIiERi4kREREQkEhMnIiIiIpGYOBERERGJxMSJiIiISCQmTkREREQiMXEiIiIiEomJExEREZFITJyIiIiIRGLiRERERCQSEyciIiIikZg4EREREYnExImIiIhIJCZORERERCIxcSIiIiISiYkTERERkUhMnIiIiIhEYuJEREREJBITJyIiIiKRmDgRERERicTEiYiIiEgkJk5EREREIjFxIiIiIhKJiRMRERGRSEyciIiIiERi4kREREQkEhMnIiIiIpGYOBERERGJxMSJiIiISCQmTkREREQiMXEiIiIiEomJExEREZFITJyIiIiIRGLiRERERCQSEyciIiIikZg4EREREYnExImIiIhIJCZONdi9ezdatWoFT09PrFmzRtfhEBERkQ4Z6ToAfVZeXo7o6GgkJyfDxsYG7du3x8CBA2FnZ6fr0IiIiEgHeMapGqdOnYK3tzccHR1haWmJ0NBQHDhwQNdhERERkY680InT0aNHERYWBqlUColEgp07dyrViY2NhZubG8zMzNCpUyecOnVKvu727dtwdHSULzs6OiIzM7M+QiciIiI99EInTsXFxfDx8UFsbKzK9QkJCYiOjsb8+fNx7tw5+Pj4ICQkBLm5ufUcKRERET0PXug5TqGhoQgNDa1y/fLlyxEREYHRo0cDAOLi4rBnzx6sXbsWM2fOhFQqVTjDlJmZCT8/vyrbe/ToER49eiRfLiws1MBeUL0ouAWU3FEuz79c/7GIiUFsXFXV08R+1SUuddvV5nY1taEPx0B1tPkZ60BWURbuPbqnemXhDcDEGLh55Mn3z7A1tkQzc/uqG7ewAxo6ayROfVHteNXkQQ7w8H7V681sAKumKlfZmtqimWWzqret6ncqUPPnUN22YrbXshc6capOWVkZzp49i1mzZsnLDAwMEBwcjBMnTgAA/Pz8kJaWhszMTNjY2GDfvn2YO3dulW0uWbIECxcu1HrspGEFt4BYP+Bxier1xhZPflDrm4Xdk763R6heX11cNW1b0/baiqsu7Yqhb/ukTdr8jHUkqygL/Xf1R2l5adWVHJsBl1Tf4Wwuk2HXP1loVlGheltjCyDy1AuTPIkaLy0xNzLHrv67VCdPYn6nVvU51LRtTdvXg5c2ccrPz0dFRQWaNlXMpps2bYqLFy8CAIyMjLBs2TIEBgZCJpNhxowZ1d5RN2vWLERHR8uXCwsL4ez8YvyAvtBK7jz5IR20GrBvqbxeV/+7aej85JdDbf7XVtO2NW2vrbjq0q4Y+rZP2qTNz1hH7j26h9LyUizxX4LmNs1VV6riLMn14kzMSovDvbfXopm1m/J2+ZefJJkld56rMamOqPGqSt5lYPtYIGgu0NBVeX1BBnDoI2DQGqCx4u/F6/evY1bKLNx7dE914lTd79SaPoeafh/rwef40iZOYvXr1w/9+vUTVdfU1BSmpqZajoi0xr4lIPXVdRSKGjrX/pdDXbbVVdvajFmf+66t5zFmEZrbNIeXnZfqlVWV37kApMU9+SNfVZ0XVLXjVZVHZUDZY8Clh+rfe7dTgbJ5gLVb7cezLr9T9fH38f+80JPDq2Nvbw9DQ0Pk5OQolOfk5MDBwUFHUREREZE+e2kTJxMTE7Rv3x5JSUnyMplMhqSkJHTu3FmHkREREZG+eqEv1RUVFeHq1avy5fT0dKSmpqJRo0ZwcXFBdHQ0wsPD0aFDB/j5+SEmJgbFxcXyu+yIiIiInvZCJ05nzpxBYGCgfLly4nZ4eDji4+MxdOhQ5OXlYd68ecjOzoavry/279+vNGGciIiICHjBE6eAgAAIglBtnaioKERFRdVTRERERPQ8e2nnOBERERGpi4kTERERkUhMnIiIiIhEYuJEREREJBITJyIiIiKRXui76nSt8o6+wsJCHUdC1XpQBDwSnvzLz4o0qaZji8eegqIHRagorUDRgyIUGqs3HjVuq69jXV1cNcRcl/Gqy7FZp7Gu68+Elj7Hyr/TNd2JDwASQUwtqpV//vmHL/klIiJ6Tty6dQtOTk7V1mHipEUymQy3b9+GlZUVJBKJwrqOHTvi9OnT1ZZVt1xYWAhnZ2fcunUL1tbWGo1bVWya2KamOlWtr8tYaXOcqou5rttUV0cb4wTwmOIxxWNKTB0eU+LqPG/HlCAIePDgAaRSKQwMqp/FxEt1WmRgYFBl5mpoaKj0oT9bVtMyAFhbW2v8B01VP5rYpqY6Va3XxFhpY5yqi7mu21RXR5vjBPCYErvMY0rcMsBjSuwyjylxy4B2xsrGxkZUPU4O15HIyMgay2pa1pba9CNmm5rqVLWeYyVuHcdJ/HqOlbh1HCfx6zlW4tbp8ziJxUt1z6nCwkLY2Njg/v37WvkfyouC4yQex0ocjpN4HCtxOE7i6cNY8YzTc8rU1BTz58+HqamprkPRaxwn8ThW4nCcxONYicNxEk8fxopnnIiIiIhE4hknIiIiIpGYOBERERGJxMSJiIiISCQmTkREREQiMXF6CaSnpyMwMBBeXl549dVXUVxcrOuQ9JKbmxvatm0LX19fBAYG6jocvVdSUgJXV1dMmzZN16HopYKCAnTo0AG+vr5o06YNVq9ereuQ9NatW7cQEBAALy8vtG3bFlu2bNF1SHpt4MCBsLW1xVtvvaXrUPTK7t270apVK3h6emLNmjVa64d31b0EevTogY8//hj+/v64e/curK2tYWTEh8Y/y83NDWlpabC0tNR1KM+FOXPm4OrVq3B2dsYXX3yh63D0TkVFBR49egQLCwsUFxejTZs2OHPmDOzs7HQdmt7JyspCTk4OfH19kZ2djfbt2+Py5cto0KCBrkPTS4cPH8aDBw/w/fffY+vWrboORy+Ul5fDy8sLycnJsLGxQfv27fHbb79p5eeNZ5xecH/99ReMjY3h7+8PAGjUqBGTJqqzK1eu4OLFiwgNDdV1KHrL0NAQFhYWAIBHjx5BEARRb15/GTVr1gy+vr4AAAcHB9jb2+Pu3bu6DUqPBQQEwMrKStdh6JVTp07B29sbjo6OsLS0RGhoKA4cOKCVvpg46djRo0cRFhYGqVQKiUSCnTt3KtWJjY2Fm5sbzMzM0KlTJ5w6dUp0+1euXIGlpSXCwsLw2muvYfHixRqMvv5oe5wAQCKRoEePHujYsSM2btyoocjrX32M1bRp07BkyRINRawb9TFOBQUF8PHxgZOTE6ZPnw57e3sNRV+/6mOsKp09exYVFRVwdnauY9S6UZ9j9SKp67jdvn0bjo6O8mVHR0dkZmZqJVYmTjpWXFwMHx8fxMbGqlyfkJCA6OhozJ8/H+fOnYOPjw9CQkKQm5srr1M5h+LZr9u3b6O8vBwpKSn473//ixMnTiAxMRGJiYn1tXsao+1xAoBjx47h7Nmz+Pnnn7F48WKcP3++XvZN07Q9Vrt27ULLli3RsmXL+tolraiPY6phw4b4448/kJ6ejk2bNiEnJ6de9k3T6mOsAODu3bsYOXIkvv32W63vk7bU11i9aDQxbvVGIL0BQNixY4dCmZ+fnxAZGSlfrqioEKRSqbBkyRJRbf72229C79695cuff/658Pnnn2skXl3Rxjg9a9q0acK6devqEKV+0MZYzZw5U3BychJcXV0FOzs7wdraWli4cKEmw6539XFMTZgwQdiyZUtdwtQL2hqrhw8fCv7+/sL69es1FarOafO4Sk5OFgYPHqyJMPVObcbt+PHjwoABA+TrJ02aJGzcuFEr8fGMkx4rKyvD2bNnERwcLC8zMDBAcHAwTpw4IaqNjh07Ijc3F/fu3YNMJsPRo0fRunVrbYWsE5oYp+LiYjx48AAAUFRUhEOHDsHb21sr8eqSJsZqyZIluHXrFm7cuIEvvvgCERERmDdvnrZC1glNjFNOTo78mLp//z6OHj2KVq1aaSVeXdLEWAmCgFGjRiEoKAjvvfeetkLVOU2M1ctIzLj5+fkhLS0NmZmZKCoqwr59+xASEqKVeDhLWI/l5+ejoqICTZs2VShv2rQpLl68KKoNIyMjLF68GN27d4cgCOjduzf69u2rjXB1RhPjlJOTg4EDBwJ4cjdUREQEOnbsqPFYdU0TY/Uy0MQ4ZWRkYNy4cfJJ4f/5z3/w6quvaiNcndLEWB0/fhwJCQlo27atfG7Lhg0bXrjx0tTPX3BwMP744w8UFxfDyckJW7ZsQefOnTUdrt4QM25GRkZYtmwZAgMDIZPJMGPGDK3dwcrE6SUQGhrKu59q0Lx5c/zxxx+6DuO5M2rUKF2HoLf8/PyQmpqq6zCeC926dYNMJtN1GM+NgwcP6joEvdSvXz/069dP6/3wUp0es7e3h6GhodKE0pycHDg4OOgoKv3DcRKPYyUOx0k8jpV4HKva0bdxY+Kkx0xMTNC+fXskJSXJy2QyGZKSkl7o07Lq4jiJx7ESh+MkHsdKPI5V7ejbuPFSnY4VFRXh6tWr8uX09HSkpqaiUaNGcHFxQXR0NMLDw9GhQwf4+fkhJiYGxcXFGD16tA6jrn8cJ/E4VuJwnMTjWInHsaqd52rctHKvHomWnJwsAFD6Cg8Pl9dZsWKF4OLiIpiYmAh+fn7CyZMndRewjnCcxONYicNxEo9jJR7Hqnaep3Hju+qIiIiIROIcJyIiIiKRmDgRERERicTEiYiIiEgkJk5EREREIjFxIiIiIhKJiRMRERGRSEyciIiIiERi4kREREQkEhMnIiIiIpGYOBERERGJxMSJiF5qo0aNgkQiwfjx45XWRUZGQiKRYNSoUQCAvLw8TJgwAS4uLjA1NYWDgwNCQkJw/Phx+TZubm6QSCRKX59++ml97RIRaZGRrgMgItI1Z2dnbN68GV9++SXMzc0BAA8fPsSmTZvg4uIirzd48GCUlZXh+++/R/PmzZGTk4OkpCTcuXNHob1FixYhIiJCoczKykr7O0JEWsfEiYheeq+99hquXbuG7du3Y8SIEQCA7du3w8XFBe7u7gCAgoICpKSk4PDhw+jRowcAwNXVFX5+fkrtWVlZwcHBof52gIjqDS/VEREBGDNmDNatWydfXrt2LUaPHi1ftrS0hKWlJXbu3IlHjx7pIkQi0gNMnIiIALz77rs4duwYMjIykJGRgePHj+Pdd9+VrzcyMkJ8fDy+//57NGzYEF27dsXs2bNx/vx5pbY++OADeaJV+ZWSklKfu0NEWsJLdUREABo3bow+ffogPj4egiCgT58+sLe3V6gzePBg9OnTBykpKTh58iT27duHzz//HGvWrJFPIAeA6dOnKywDgKOjYz3sBRFpGxMnIqL/GTNmDKKiogAAsbGxKuuYmZmhV69e6NWrF+bOnYuxY8di/vz5ComSvb09PDw86iNkIqpnvFRHRPQ/b7zxBsrKyvD48WOEhISI2sbLywvFxcVajoyI9AXPOBER/Y+hoSH+/vtv+fdPu3PnDt5++22MGTMGbdu2hZWVFc6cOYPPP/8c/fv3V6j74MEDZGdnK5RZWFjA2tpauztARFrHxImI6ClVJTeWlpbo1KkTvvzyS1y7dg2PHz+Gs7MzIiIiMHv2bIW68+bNw7x58xTK/vWvfyEuLk5rcRNR/ZAIgiDoOggiIiKi5wHnOBERERGJxMSJiIiISCQmTkREREQiMXEiIiIiEomJExEREZFITJyIiIiIRGLiRERERCQSEyciIiIikZg4EREREYnExImIiIhIJCZORERERCIxcSIiIiIS6f8DZrLJdpIDKBEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def plot_loss_histograms(df, metrics=(\"combined\", \"BCE\", \"MSE\")):\n", + " \"\"\"\n", + " Draw log-scaled histograms for the requested loss metrics.\n", + " Each figure overlays the distributions for 0-hit, 1-hit and 2-hit cells.\n", + "\n", + " Parameters\n", + " ----------\n", + " df : pandas.DataFrame\n", + " must contain columns: num_hits, combined, BCE, MSE\n", + " metrics : iterable[str]\n", + " which columns to plot; default = all three\n", + " \"\"\"\n", + " # pick up the three groups\n", + " groups = {h: df[df.num_hits == h] for h in (0, 1, 2)}\n", + "\n", + " for metric in metrics:\n", + " # skip if metric column missing\n", + " if metric not in df.columns:\n", + " print(f\"⚠ column '{metric}' not found – skipping.\")\n", + " continue\n", + "\n", + " plt.figure(figsize=(6, 4))\n", + " # overlay a histogram for each hit-count that exists\n", + " for h, g in groups.items():\n", + " if g.empty:\n", + " continue\n", + " plt.hist(g[metric],\n", + " bins=np.logspace(-6, 0, 60), # wide range on log-x\n", + " histtype='step', # outline only; default colour-cycle\n", + " label=f\"{h}-hit ({len(g)})\",\n", + " log=True) # log y-axis\n", + "\n", + " plt.xscale(\"log\")\n", + " plt.xlabel(metric)\n", + " plt.ylabel(\"count (log scale)\")\n", + " plt.title(f\"Distribution of {metric} per cell\")\n", + " plt.legend()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# ─── usage ─────────────────────────────────────────────────────\n", + "plot_loss_histograms(df_summary) # uses the dataframe you already built\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "b2b2bd11", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frame 8317 — 100 GT hits, 104 predictions\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-05-23 01:31:37.579115: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
grid_rgrid_cslotpnxnyx_pxy_pxtag
00201.0000000.6250000.50000017.0000000.000000Ground‑truth
10200.9967530.7082650.50684217.6661220.054737Prediction
202301.0000000.3750000.875000183.0000003.000000Ground‑truth
302300.9706130.3463450.816721182.7707592.533768Prediction
41601.0000000.2500000.50000046.0000008.000000Ground‑truth
51600.8964800.3186950.59437846.5495568.755027Prediction
61611.0000000.1250000.62500045.0000009.000000Ground‑truth
711301.0000000.6250000.250000105.0000006.000000Ground‑truth
811300.9981650.6008590.256689104.8068766.053515Prediction
911401.0000000.5000000.625000112.0000009.000000Ground‑truth
1011400.9983220.5103630.625031112.0829029.000248Prediction
1112301.0000000.8750000.375000187.0000007.000000Ground‑truth
1212300.8736980.8801910.377398187.0415247.019181Prediction
1312401.0000000.3750000.000000191.0000004.000000Ground‑truth
1412400.8623870.2952140.033898190.3617114.271182Prediction
152201.0000000.3750000.00000015.00000012.000000Ground‑truth
162200.6316450.6770880.13918917.41670313.113513Prediction
1722601.0000000.7500000.125000210.00000013.000000Ground‑truth
1822701.0000000.2500000.125000214.00000013.000000Ground‑truth
1922700.8853180.2591130.026929214.07290312.215429Prediction
2041201.0000000.5000000.75000096.00000034.000000Ground‑truth
2141200.9510680.5133210.66563796.10657033.325095Prediction
2242201.0000000.8750000.750000179.00000034.000000Ground‑truth
2342200.8872160.8793840.745946179.03507533.967571Prediction
245501.0000000.5000000.50000040.00000040.000000Ground‑truth
255500.9976750.5058270.50508140.04661640.040651Prediction
2652401.0000000.1250000.750000189.00000042.000000Ground‑truth
2752400.9825020.1403380.745887189.12270741.967096Prediction
2852601.0000000.2500000.500000206.00000040.000000Ground‑truth
2952600.9982390.2643310.503797206.11464540.030377Prediction
306701.0000000.8750000.25000059.00000046.000000Ground‑truth
316700.8721030.8741960.24946558.99356745.995718Prediction
3261101.0000000.5000000.87500088.00000051.000000Ground‑truth
3361100.8363350.4994800.87026487.99584350.962110Prediction
3461201.0000000.3750000.25000095.00000046.000000Ground‑truth
3561200.9972980.3851020.24847295.08081445.987777Prediction
367201.0000000.0000000.50000012.00000056.000000Ground‑truth
377200.8716230.0364490.40862012.29159255.268963Prediction
3871601.0000000.5000000.250000128.00000054.000000Ground‑truth
3971600.9986970.4251590.271349127.40127154.170792Prediction
4071801.0000000.5000000.750000144.00000058.000000Ground‑truth
4171800.9786450.6209160.796080144.96732558.368642Prediction
4272001.0000000.3750000.875000159.00000059.000000Ground‑truth
4372000.9037690.4117210.869537159.29377158.956294Prediction
4481001.0000000.8750000.00000083.00000060.000000Ground‑truth
4581000.6707750.8116920.02146082.49353660.171680Prediction
4681201.0000000.2500000.50000094.00000064.000000Ground‑truth
4781200.9982630.3393000.54855194.71439664.388411Prediction
4881501.0000000.2500000.125000118.00000061.000000Ground‑truth
4981500.9987570.2575800.258083118.06064162.064667Prediction
5091101.0000000.5000000.37500088.00000071.000000Ground‑truth
5191100.9970670.5126770.37101488.10141970.968116Prediction
5292101.0000000.3750000.500000167.00000072.000000Ground‑truth
5392100.9984930.3767270.503198167.01381772.025584Prediction
5492701.0000000.0000000.625000212.00000073.000000Ground‑truth
5592700.8094860.0227880.630629212.18230573.045034Prediction
5610200.5151210.0346260.85237212.27701282.818977Prediction
57101001.0000000.2500000.87500078.00000083.000000Ground‑truth
58101000.8081970.2575390.86703478.06031382.936270Prediction
59101601.0000000.1250000.750000125.00000082.000000Ground‑truth
60101600.9608850.1066330.755281124.85306782.042245Prediction
61103001.0000000.2500000.875000238.00000083.000000Ground‑truth
62103000.8918290.3318980.871984238.65518582.975871Prediction
6311201.0000000.0000000.00000012.00000084.000000Ground‑truth
6411200.9881150.7746500.45064518.19719787.605159Prediction
6511211.0000000.7500000.62500018.00000089.000000Ground‑truth
6611210.7661880.0870500.02629512.69640284.210359Prediction
67111901.0000000.3750000.500000151.00000088.000000Ground‑truth
68111900.9989270.4008470.482941151.20677387.863530Prediction
69112301.0000000.3750000.375000183.00000087.000000Ground‑truth
70112300.9892080.4717210.360969183.77376986.887755Prediction
71112801.0000000.8750000.500000227.00000088.000000Ground‑truth
72112800.9201890.8774930.534597227.01994688.276773Prediction
73112901.0000000.5000000.125000232.00000085.000000Ground‑truth
74112900.9894940.5154650.117202232.12371784.937613Prediction
75113001.0000000.0000000.500000236.00000088.000000Ground‑truth
76113000.8269650.0233480.500286236.18678688.002291Prediction
7712201.0000000.1250000.12500013.00000093.000000Ground‑truth
7812200.9739610.0606030.14492012.48482693.159362Prediction
7912601.0000000.6250000.00000049.00000092.000000Ground‑truth
8012600.8577470.6349320.01079849.07945692.086381Prediction
81122200.5576800.8797210.857036179.03776898.856287Prediction
82122301.0000000.2500000.625000182.00000097.000000Ground‑truth
83122300.7583560.0161550.864984180.12924298.919875Prediction
84122401.0000000.7500000.125000194.00000093.000000Ground‑truth
85122400.9830720.7692080.109969194.15366692.879753Prediction
86122501.0000000.7500000.375000202.00000095.000000Ground‑truth
87122500.9841640.7774520.389698202.21961795.117583Prediction
88122701.0000000.5000000.625000216.00000097.000000Ground‑truth
89122700.9010660.5569930.543853216.45594296.350826Prediction
90122711.0000000.7500000.375000218.00000095.000000Ground‑truth
91131701.0000000.8750000.500000139.000000104.000000Ground‑truth
92131700.7172500.8814630.495889139.051702103.967112Prediction
93131800.6477490.0234450.503577140.187558104.028612Prediction
94132200.5529170.7972980.018550178.378382100.148403Prediction
9514201.0000000.3750000.62500015.000000113.000000Ground‑truth
9614200.9960630.4021010.67100815.216805113.368065Prediction
97141800.7223330.8744210.081569146.995371108.652550Prediction
98141901.0000000.0000000.000000148.000000108.000000Ground‑truth
9915401.0000000.1250000.00000029.000000116.000000Ground‑truth
10015400.6623450.1471780.00252829.177425116.020223Prediction
10115901.0000000.6250000.12500073.000000117.000000Ground‑truth
10215900.9952130.6762410.22298273.409930117.783856Prediction
103152201.0000000.5000000.875000176.000000123.000000Ground‑truth
104152501.0000000.7500000.375000202.000000119.000000Ground‑truth
105152500.9938540.7293480.380865201.834783119.046922Prediction
106152601.0000000.3750000.875000207.000000123.000000Ground‑truth
107152600.9462290.4000860.848448207.200689122.787586Prediction
10816201.0000000.2500000.50000014.000000128.000000Ground‑truth
10916200.9987000.2516110.45480614.012892127.638445Prediction
11016301.0000000.7500000.00000026.000000124.000000Ground‑truth
11116300.8740460.7599300.00615626.079444124.049248Prediction
112162200.8110690.5143380.004713176.114708124.037707Prediction
113162401.0000000.3750000.125000191.000000125.000000Ground‑truth
114162400.9545540.3798320.126960191.038654125.015680Prediction
11517301.0000000.7500000.75000026.000000138.000000Ground‑truth
11617300.9595380.6860140.72525925.488110137.802072Prediction
11717311.0000000.5000000.50000024.000000136.000000Ground‑truth
11817801.0000000.8750000.50000067.000000136.000000Ground‑truth
11917800.8876310.8755350.50452167.004279136.036170Prediction
120171001.0000000.5000000.12500080.000000133.000000Ground‑truth
121171000.9925250.4135670.13386779.308535133.070936Prediction
122171501.0000000.6250000.000000121.000000132.000000Ground‑truth
123171500.9899440.6343360.078938121.074687132.631500Prediction
124173001.0000000.1250000.500000237.000000136.000000Ground‑truth
125173000.9923930.1857930.489621237.486341135.916970Prediction
126173011.0000000.5000000.125000240.000000133.000000Ground‑truth
127173010.8728630.6534530.075511241.227623132.604088Prediction
128181201.0000000.0000000.50000092.000000144.000000Ground‑truth
129181200.9781990.0584790.55955992.467833144.476476Prediction
13019301.0000000.8750000.50000027.000000152.000000Ground‑truth
13119300.8764620.8840300.49893327.072237151.991461Prediction
132192801.0000000.0000000.000000220.000000148.000000Ground‑truth
133192800.7731040.0911170.080090220.728937148.640722Prediction
13420301.0000000.8750000.62500027.000000161.000000Ground‑truth
13520300.9632530.8504400.56191126.803518160.495288Prediction
13620401.0000000.5000000.25000032.000000158.000000Ground‑truth
13720400.9989550.5619480.25614332.495582158.049144Prediction
138201701.0000000.2500000.125000134.000000157.000000Ground‑truth
139201700.8298680.2041760.010786133.633406156.086288Prediction
140212401.0000000.1250000.750000189.000000170.000000Ground‑truth
141212400.9907120.1302660.749284189.042125169.994269Prediction
142212501.0000000.5000000.500000200.000000168.000000Ground‑truth
143212500.9964820.4477510.496270199.582009167.970161Prediction
14422001.0000000.6250000.6250001.000000177.000000Ground‑truth
14522000.9976070.6338260.7527241.070608178.021792Prediction
146223101.0000000.3750000.500000247.000000176.000000Ground‑truth
147223100.9974940.3861330.502894247.089067176.023153Prediction
14823601.0000000.0000000.75000044.000000186.000000Ground‑truth
14923600.9960980.1290460.75059245.032368186.004737Prediction
15023901.0000000.8750000.37500075.000000183.000000Ground‑truth
15123900.7696670.8070530.35420874.456424182.833664Prediction
152231801.0000000.2500000.625000142.000000185.000000Ground‑truth
153231800.9976520.2739710.670011142.191767185.360091Prediction
154233001.0000000.3750000.000000239.000000180.000000Ground‑truth
155233000.9873000.4627260.509449239.701810184.075593Prediction
156233010.5057460.3613770.164154238.891013181.313234Prediction
15724700.6893730.8725590.37933858.980468191.034707Prediction
15824801.0000000.0000000.37500060.000000191.000000Ground‑truth
15924800.5576420.0323290.37229660.258636190.978370Prediction
160241401.0000000.6250000.500000113.000000192.000000Ground‑truth
161241400.9981540.6303310.553670113.042645192.429357Prediction
162241901.0000000.1250000.000000149.000000188.000000Ground‑truth
163241900.8038020.1425550.023599149.140443188.188789Prediction
16425401.0000000.8750000.50000035.000000200.000000Ground‑truth
16525400.7172500.8814630.49588935.051702199.967112Prediction
16625500.6790490.0244640.50141636.195715200.011327Prediction
16725601.0000000.3750000.25000047.000000198.000000Ground‑truth
16825600.9984360.4506410.25491647.605131198.039326Prediction
16925801.0000000.8750000.87500067.000000203.000000Ground‑truth
17025800.8451040.8621440.86485566.897152202.918840Prediction
171251600.9094290.5806030.874137128.644827202.993100Prediction
172252601.0000000.3750000.500000207.000000200.000000Ground‑truth
173252600.9958810.3749810.504680206.999848200.037438Prediction
17426801.0000000.3750000.37500063.000000207.000000Ground‑truth
17526800.9931510.3126400.50877962.501123208.070233Prediction
176261601.0000000.5000000.000000128.000000204.000000Ground‑truth
177263101.0000000.5000000.750000248.000000210.000000Ground‑truth
178263100.9969690.4771680.709477247.817341209.675816Prediction
17927501.0000000.8750000.25000043.000000214.000000Ground‑truth
18027500.6381770.8813100.24889143.050481213.991127Prediction
18127600.6474280.0198000.25889144.158400214.071126Prediction
18227901.0000000.5000000.62500072.000000217.000000Ground‑truth
18327900.9933610.5018210.63167672.014565217.053410Prediction
184272701.0000000.3750000.250000215.000000214.000000Ground‑truth
185272700.9978010.3789580.251520215.031667214.012159Prediction
186281200.8585680.7934010.38562198.347209223.084970Prediction
187281301.0000000.0000000.750000100.000000226.000000Ground‑truth
188281300.9951410.1403760.141558101.123006221.132467Prediction
189281311.0000000.1250000.125000101.000000221.000000Ground‑truth
19029901.0000000.8750000.62500075.000000233.000000Ground‑truth
19129900.6322490.8801490.62335375.041193232.986823Prediction
192292801.0000000.3750000.625000223.000000233.000000Ground‑truth
193292800.9968550.3859120.621256223.087294232.970050Prediction
19430401.0000000.6250000.37500033.000000239.000000Ground‑truth
19530400.9975640.6321440.37121433.057152238.969714Prediction
19630701.0000000.7500000.75000058.000000242.000000Ground‑truth
19730700.9376640.8573320.78213858.858654242.257102Prediction
198301801.0000000.2500000.875000142.000000243.000000Ground‑truth
199311800.8853830.2973150.012906142.378520244.103247Prediction
200312401.0000000.3750000.500000191.000000248.000000Ground‑truth
201312400.9987370.4811800.490233191.849442247.921868Prediction
202312701.0000000.7500000.875000218.000000251.000000Ground‑truth
203312700.7795580.7601930.868559218.081547250.948474Prediction
\n", + "
" + ], + "text/plain": [ + " grid_r grid_c slot p nx ny x_px \\\n", + "0 0 2 0 1.000000 0.625000 0.500000 17.000000 \n", + "1 0 2 0 0.996753 0.708265 0.506842 17.666122 \n", + "2 0 23 0 1.000000 0.375000 0.875000 183.000000 \n", + "3 0 23 0 0.970613 0.346345 0.816721 182.770759 \n", + "4 1 6 0 1.000000 0.250000 0.500000 46.000000 \n", + "5 1 6 0 0.896480 0.318695 0.594378 46.549556 \n", + "6 1 6 1 1.000000 0.125000 0.625000 45.000000 \n", + "7 1 13 0 1.000000 0.625000 0.250000 105.000000 \n", + "8 1 13 0 0.998165 0.600859 0.256689 104.806876 \n", + "9 1 14 0 1.000000 0.500000 0.625000 112.000000 \n", + "10 1 14 0 0.998322 0.510363 0.625031 112.082902 \n", + "11 1 23 0 1.000000 0.875000 0.375000 187.000000 \n", + "12 1 23 0 0.873698 0.880191 0.377398 187.041524 \n", + "13 1 24 0 1.000000 0.375000 0.000000 191.000000 \n", + "14 1 24 0 0.862387 0.295214 0.033898 190.361711 \n", + "15 2 2 0 1.000000 0.375000 0.000000 15.000000 \n", + "16 2 2 0 0.631645 0.677088 0.139189 17.416703 \n", + "17 2 26 0 1.000000 0.750000 0.125000 210.000000 \n", + "18 2 27 0 1.000000 0.250000 0.125000 214.000000 \n", + "19 2 27 0 0.885318 0.259113 0.026929 214.072903 \n", + "20 4 12 0 1.000000 0.500000 0.750000 96.000000 \n", + "21 4 12 0 0.951068 0.513321 0.665637 96.106570 \n", + "22 4 22 0 1.000000 0.875000 0.750000 179.000000 \n", + "23 4 22 0 0.887216 0.879384 0.745946 179.035075 \n", + "24 5 5 0 1.000000 0.500000 0.500000 40.000000 \n", + "25 5 5 0 0.997675 0.505827 0.505081 40.046616 \n", + "26 5 24 0 1.000000 0.125000 0.750000 189.000000 \n", + "27 5 24 0 0.982502 0.140338 0.745887 189.122707 \n", + "28 5 26 0 1.000000 0.250000 0.500000 206.000000 \n", + "29 5 26 0 0.998239 0.264331 0.503797 206.114645 \n", + "30 6 7 0 1.000000 0.875000 0.250000 59.000000 \n", + "31 6 7 0 0.872103 0.874196 0.249465 58.993567 \n", + "32 6 11 0 1.000000 0.500000 0.875000 88.000000 \n", + "33 6 11 0 0.836335 0.499480 0.870264 87.995843 \n", + "34 6 12 0 1.000000 0.375000 0.250000 95.000000 \n", + "35 6 12 0 0.997298 0.385102 0.248472 95.080814 \n", + "36 7 2 0 1.000000 0.000000 0.500000 12.000000 \n", + "37 7 2 0 0.871623 0.036449 0.408620 12.291592 \n", + "38 7 16 0 1.000000 0.500000 0.250000 128.000000 \n", + "39 7 16 0 0.998697 0.425159 0.271349 127.401271 \n", + "40 7 18 0 1.000000 0.500000 0.750000 144.000000 \n", + "41 7 18 0 0.978645 0.620916 0.796080 144.967325 \n", + "42 7 20 0 1.000000 0.375000 0.875000 159.000000 \n", + "43 7 20 0 0.903769 0.411721 0.869537 159.293771 \n", + "44 8 10 0 1.000000 0.875000 0.000000 83.000000 \n", + "45 8 10 0 0.670775 0.811692 0.021460 82.493536 \n", + "46 8 12 0 1.000000 0.250000 0.500000 94.000000 \n", + "47 8 12 0 0.998263 0.339300 0.548551 94.714396 \n", + "48 8 15 0 1.000000 0.250000 0.125000 118.000000 \n", + "49 8 15 0 0.998757 0.257580 0.258083 118.060641 \n", + "50 9 11 0 1.000000 0.500000 0.375000 88.000000 \n", + "51 9 11 0 0.997067 0.512677 0.371014 88.101419 \n", + "52 9 21 0 1.000000 0.375000 0.500000 167.000000 \n", + "53 9 21 0 0.998493 0.376727 0.503198 167.013817 \n", + "54 9 27 0 1.000000 0.000000 0.625000 212.000000 \n", + "55 9 27 0 0.809486 0.022788 0.630629 212.182305 \n", + "56 10 2 0 0.515121 0.034626 0.852372 12.277012 \n", + "57 10 10 0 1.000000 0.250000 0.875000 78.000000 \n", + "58 10 10 0 0.808197 0.257539 0.867034 78.060313 \n", + "59 10 16 0 1.000000 0.125000 0.750000 125.000000 \n", + "60 10 16 0 0.960885 0.106633 0.755281 124.853067 \n", + "61 10 30 0 1.000000 0.250000 0.875000 238.000000 \n", + "62 10 30 0 0.891829 0.331898 0.871984 238.655185 \n", + "63 11 2 0 1.000000 0.000000 0.000000 12.000000 \n", + "64 11 2 0 0.988115 0.774650 0.450645 18.197197 \n", + "65 11 2 1 1.000000 0.750000 0.625000 18.000000 \n", + "66 11 2 1 0.766188 0.087050 0.026295 12.696402 \n", + "67 11 19 0 1.000000 0.375000 0.500000 151.000000 \n", + "68 11 19 0 0.998927 0.400847 0.482941 151.206773 \n", + "69 11 23 0 1.000000 0.375000 0.375000 183.000000 \n", + "70 11 23 0 0.989208 0.471721 0.360969 183.773769 \n", + "71 11 28 0 1.000000 0.875000 0.500000 227.000000 \n", + "72 11 28 0 0.920189 0.877493 0.534597 227.019946 \n", + "73 11 29 0 1.000000 0.500000 0.125000 232.000000 \n", + "74 11 29 0 0.989494 0.515465 0.117202 232.123717 \n", + "75 11 30 0 1.000000 0.000000 0.500000 236.000000 \n", + "76 11 30 0 0.826965 0.023348 0.500286 236.186786 \n", + "77 12 2 0 1.000000 0.125000 0.125000 13.000000 \n", + "78 12 2 0 0.973961 0.060603 0.144920 12.484826 \n", + "79 12 6 0 1.000000 0.625000 0.000000 49.000000 \n", + "80 12 6 0 0.857747 0.634932 0.010798 49.079456 \n", + "81 12 22 0 0.557680 0.879721 0.857036 179.037768 \n", + "82 12 23 0 1.000000 0.250000 0.625000 182.000000 \n", + "83 12 23 0 0.758356 0.016155 0.864984 180.129242 \n", + "84 12 24 0 1.000000 0.750000 0.125000 194.000000 \n", + "85 12 24 0 0.983072 0.769208 0.109969 194.153666 \n", + "86 12 25 0 1.000000 0.750000 0.375000 202.000000 \n", + "87 12 25 0 0.984164 0.777452 0.389698 202.219617 \n", + "88 12 27 0 1.000000 0.500000 0.625000 216.000000 \n", + "89 12 27 0 0.901066 0.556993 0.543853 216.455942 \n", + "90 12 27 1 1.000000 0.750000 0.375000 218.000000 \n", + "91 13 17 0 1.000000 0.875000 0.500000 139.000000 \n", + "92 13 17 0 0.717250 0.881463 0.495889 139.051702 \n", + "93 13 18 0 0.647749 0.023445 0.503577 140.187558 \n", + "94 13 22 0 0.552917 0.797298 0.018550 178.378382 \n", + "95 14 2 0 1.000000 0.375000 0.625000 15.000000 \n", + "96 14 2 0 0.996063 0.402101 0.671008 15.216805 \n", + "97 14 18 0 0.722333 0.874421 0.081569 146.995371 \n", + "98 14 19 0 1.000000 0.000000 0.000000 148.000000 \n", + "99 15 4 0 1.000000 0.125000 0.000000 29.000000 \n", + "100 15 4 0 0.662345 0.147178 0.002528 29.177425 \n", + "101 15 9 0 1.000000 0.625000 0.125000 73.000000 \n", + "102 15 9 0 0.995213 0.676241 0.222982 73.409930 \n", + "103 15 22 0 1.000000 0.500000 0.875000 176.000000 \n", + "104 15 25 0 1.000000 0.750000 0.375000 202.000000 \n", + "105 15 25 0 0.993854 0.729348 0.380865 201.834783 \n", + "106 15 26 0 1.000000 0.375000 0.875000 207.000000 \n", + "107 15 26 0 0.946229 0.400086 0.848448 207.200689 \n", + "108 16 2 0 1.000000 0.250000 0.500000 14.000000 \n", + "109 16 2 0 0.998700 0.251611 0.454806 14.012892 \n", + "110 16 3 0 1.000000 0.750000 0.000000 26.000000 \n", + "111 16 3 0 0.874046 0.759930 0.006156 26.079444 \n", + "112 16 22 0 0.811069 0.514338 0.004713 176.114708 \n", + "113 16 24 0 1.000000 0.375000 0.125000 191.000000 \n", + "114 16 24 0 0.954554 0.379832 0.126960 191.038654 \n", + "115 17 3 0 1.000000 0.750000 0.750000 26.000000 \n", + "116 17 3 0 0.959538 0.686014 0.725259 25.488110 \n", + "117 17 3 1 1.000000 0.500000 0.500000 24.000000 \n", + "118 17 8 0 1.000000 0.875000 0.500000 67.000000 \n", + "119 17 8 0 0.887631 0.875535 0.504521 67.004279 \n", + "120 17 10 0 1.000000 0.500000 0.125000 80.000000 \n", + "121 17 10 0 0.992525 0.413567 0.133867 79.308535 \n", + "122 17 15 0 1.000000 0.625000 0.000000 121.000000 \n", + "123 17 15 0 0.989944 0.634336 0.078938 121.074687 \n", + "124 17 30 0 1.000000 0.125000 0.500000 237.000000 \n", + "125 17 30 0 0.992393 0.185793 0.489621 237.486341 \n", + "126 17 30 1 1.000000 0.500000 0.125000 240.000000 \n", + "127 17 30 1 0.872863 0.653453 0.075511 241.227623 \n", + "128 18 12 0 1.000000 0.000000 0.500000 92.000000 \n", + "129 18 12 0 0.978199 0.058479 0.559559 92.467833 \n", + "130 19 3 0 1.000000 0.875000 0.500000 27.000000 \n", + "131 19 3 0 0.876462 0.884030 0.498933 27.072237 \n", + "132 19 28 0 1.000000 0.000000 0.000000 220.000000 \n", + "133 19 28 0 0.773104 0.091117 0.080090 220.728937 \n", + "134 20 3 0 1.000000 0.875000 0.625000 27.000000 \n", + "135 20 3 0 0.963253 0.850440 0.561911 26.803518 \n", + "136 20 4 0 1.000000 0.500000 0.250000 32.000000 \n", + "137 20 4 0 0.998955 0.561948 0.256143 32.495582 \n", + "138 20 17 0 1.000000 0.250000 0.125000 134.000000 \n", + "139 20 17 0 0.829868 0.204176 0.010786 133.633406 \n", + "140 21 24 0 1.000000 0.125000 0.750000 189.000000 \n", + "141 21 24 0 0.990712 0.130266 0.749284 189.042125 \n", + "142 21 25 0 1.000000 0.500000 0.500000 200.000000 \n", + "143 21 25 0 0.996482 0.447751 0.496270 199.582009 \n", + "144 22 0 0 1.000000 0.625000 0.625000 1.000000 \n", + "145 22 0 0 0.997607 0.633826 0.752724 1.070608 \n", + "146 22 31 0 1.000000 0.375000 0.500000 247.000000 \n", + "147 22 31 0 0.997494 0.386133 0.502894 247.089067 \n", + "148 23 6 0 1.000000 0.000000 0.750000 44.000000 \n", + "149 23 6 0 0.996098 0.129046 0.750592 45.032368 \n", + "150 23 9 0 1.000000 0.875000 0.375000 75.000000 \n", + "151 23 9 0 0.769667 0.807053 0.354208 74.456424 \n", + "152 23 18 0 1.000000 0.250000 0.625000 142.000000 \n", + "153 23 18 0 0.997652 0.273971 0.670011 142.191767 \n", + "154 23 30 0 1.000000 0.375000 0.000000 239.000000 \n", + "155 23 30 0 0.987300 0.462726 0.509449 239.701810 \n", + "156 23 30 1 0.505746 0.361377 0.164154 238.891013 \n", + "157 24 7 0 0.689373 0.872559 0.379338 58.980468 \n", + "158 24 8 0 1.000000 0.000000 0.375000 60.000000 \n", + "159 24 8 0 0.557642 0.032329 0.372296 60.258636 \n", + "160 24 14 0 1.000000 0.625000 0.500000 113.000000 \n", + "161 24 14 0 0.998154 0.630331 0.553670 113.042645 \n", + "162 24 19 0 1.000000 0.125000 0.000000 149.000000 \n", + "163 24 19 0 0.803802 0.142555 0.023599 149.140443 \n", + "164 25 4 0 1.000000 0.875000 0.500000 35.000000 \n", + "165 25 4 0 0.717250 0.881463 0.495889 35.051702 \n", + "166 25 5 0 0.679049 0.024464 0.501416 36.195715 \n", + "167 25 6 0 1.000000 0.375000 0.250000 47.000000 \n", + "168 25 6 0 0.998436 0.450641 0.254916 47.605131 \n", + "169 25 8 0 1.000000 0.875000 0.875000 67.000000 \n", + "170 25 8 0 0.845104 0.862144 0.864855 66.897152 \n", + "171 25 16 0 0.909429 0.580603 0.874137 128.644827 \n", + "172 25 26 0 1.000000 0.375000 0.500000 207.000000 \n", + "173 25 26 0 0.995881 0.374981 0.504680 206.999848 \n", + "174 26 8 0 1.000000 0.375000 0.375000 63.000000 \n", + "175 26 8 0 0.993151 0.312640 0.508779 62.501123 \n", + "176 26 16 0 1.000000 0.500000 0.000000 128.000000 \n", + "177 26 31 0 1.000000 0.500000 0.750000 248.000000 \n", + "178 26 31 0 0.996969 0.477168 0.709477 247.817341 \n", + "179 27 5 0 1.000000 0.875000 0.250000 43.000000 \n", + "180 27 5 0 0.638177 0.881310 0.248891 43.050481 \n", + "181 27 6 0 0.647428 0.019800 0.258891 44.158400 \n", + "182 27 9 0 1.000000 0.500000 0.625000 72.000000 \n", + "183 27 9 0 0.993361 0.501821 0.631676 72.014565 \n", + "184 27 27 0 1.000000 0.375000 0.250000 215.000000 \n", + "185 27 27 0 0.997801 0.378958 0.251520 215.031667 \n", + "186 28 12 0 0.858568 0.793401 0.385621 98.347209 \n", + "187 28 13 0 1.000000 0.000000 0.750000 100.000000 \n", + "188 28 13 0 0.995141 0.140376 0.141558 101.123006 \n", + "189 28 13 1 1.000000 0.125000 0.125000 101.000000 \n", + "190 29 9 0 1.000000 0.875000 0.625000 75.000000 \n", + "191 29 9 0 0.632249 0.880149 0.623353 75.041193 \n", + "192 29 28 0 1.000000 0.375000 0.625000 223.000000 \n", + "193 29 28 0 0.996855 0.385912 0.621256 223.087294 \n", + "194 30 4 0 1.000000 0.625000 0.375000 33.000000 \n", + "195 30 4 0 0.997564 0.632144 0.371214 33.057152 \n", + "196 30 7 0 1.000000 0.750000 0.750000 58.000000 \n", + "197 30 7 0 0.937664 0.857332 0.782138 58.858654 \n", + "198 30 18 0 1.000000 0.250000 0.875000 142.000000 \n", + "199 31 18 0 0.885383 0.297315 0.012906 142.378520 \n", + "200 31 24 0 1.000000 0.375000 0.500000 191.000000 \n", + "201 31 24 0 0.998737 0.481180 0.490233 191.849442 \n", + "202 31 27 0 1.000000 0.750000 0.875000 218.000000 \n", + "203 31 27 0 0.779558 0.760193 0.868559 218.081547 \n", + "\n", + " y_px tag \n", + "0 0.000000 Ground‑truth \n", + "1 0.054737 Prediction \n", + "2 3.000000 Ground‑truth \n", + "3 2.533768 Prediction \n", + "4 8.000000 Ground‑truth \n", + "5 8.755027 Prediction \n", + "6 9.000000 Ground‑truth \n", + "7 6.000000 Ground‑truth \n", + "8 6.053515 Prediction \n", + "9 9.000000 Ground‑truth \n", + "10 9.000248 Prediction \n", + "11 7.000000 Ground‑truth \n", + "12 7.019181 Prediction \n", + "13 4.000000 Ground‑truth \n", + "14 4.271182 Prediction \n", + "15 12.000000 Ground‑truth \n", + "16 13.113513 Prediction \n", + "17 13.000000 Ground‑truth \n", + "18 13.000000 Ground‑truth \n", + "19 12.215429 Prediction \n", + "20 34.000000 Ground‑truth \n", + "21 33.325095 Prediction \n", + "22 34.000000 Ground‑truth \n", + "23 33.967571 Prediction \n", + "24 40.000000 Ground‑truth \n", + "25 40.040651 Prediction \n", + "26 42.000000 Ground‑truth \n", + "27 41.967096 Prediction \n", + "28 40.000000 Ground‑truth \n", + "29 40.030377 Prediction \n", + "30 46.000000 Ground‑truth \n", + "31 45.995718 Prediction \n", + "32 51.000000 Ground‑truth \n", + "33 50.962110 Prediction \n", + "34 46.000000 Ground‑truth \n", + "35 45.987777 Prediction \n", + "36 56.000000 Ground‑truth \n", + "37 55.268963 Prediction \n", + "38 54.000000 Ground‑truth \n", + "39 54.170792 Prediction \n", + "40 58.000000 Ground‑truth \n", + "41 58.368642 Prediction \n", + "42 59.000000 Ground‑truth \n", + "43 58.956294 Prediction \n", + "44 60.000000 Ground‑truth \n", + "45 60.171680 Prediction \n", + "46 64.000000 Ground‑truth \n", + "47 64.388411 Prediction \n", + "48 61.000000 Ground‑truth \n", + "49 62.064667 Prediction \n", + "50 71.000000 Ground‑truth \n", + "51 70.968116 Prediction \n", + "52 72.000000 Ground‑truth \n", + "53 72.025584 Prediction \n", + "54 73.000000 Ground‑truth \n", + "55 73.045034 Prediction \n", + "56 82.818977 Prediction \n", + "57 83.000000 Ground‑truth \n", + "58 82.936270 Prediction \n", + "59 82.000000 Ground‑truth \n", + "60 82.042245 Prediction \n", + "61 83.000000 Ground‑truth \n", + "62 82.975871 Prediction \n", + "63 84.000000 Ground‑truth \n", + "64 87.605159 Prediction \n", + "65 89.000000 Ground‑truth \n", + "66 84.210359 Prediction \n", + "67 88.000000 Ground‑truth \n", + "68 87.863530 Prediction \n", + "69 87.000000 Ground‑truth \n", + "70 86.887755 Prediction \n", + "71 88.000000 Ground‑truth \n", + "72 88.276773 Prediction \n", + "73 85.000000 Ground‑truth \n", + "74 84.937613 Prediction \n", + "75 88.000000 Ground‑truth \n", + "76 88.002291 Prediction \n", + "77 93.000000 Ground‑truth \n", + "78 93.159362 Prediction \n", + "79 92.000000 Ground‑truth \n", + "80 92.086381 Prediction \n", + "81 98.856287 Prediction \n", + "82 97.000000 Ground‑truth \n", + "83 98.919875 Prediction \n", + "84 93.000000 Ground‑truth \n", + "85 92.879753 Prediction \n", + "86 95.000000 Ground‑truth \n", + "87 95.117583 Prediction \n", + "88 97.000000 Ground‑truth \n", + "89 96.350826 Prediction \n", + "90 95.000000 Ground‑truth \n", + "91 104.000000 Ground‑truth \n", + "92 103.967112 Prediction \n", + "93 104.028612 Prediction \n", + "94 100.148403 Prediction \n", + "95 113.000000 Ground‑truth \n", + "96 113.368065 Prediction \n", + "97 108.652550 Prediction \n", + "98 108.000000 Ground‑truth \n", + "99 116.000000 Ground‑truth \n", + "100 116.020223 Prediction \n", + "101 117.000000 Ground‑truth \n", + "102 117.783856 Prediction \n", + "103 123.000000 Ground‑truth \n", + "104 119.000000 Ground‑truth \n", + "105 119.046922 Prediction \n", + "106 123.000000 Ground‑truth \n", + "107 122.787586 Prediction \n", + "108 128.000000 Ground‑truth \n", + "109 127.638445 Prediction \n", + "110 124.000000 Ground‑truth \n", + "111 124.049248 Prediction \n", + "112 124.037707 Prediction \n", + "113 125.000000 Ground‑truth \n", + "114 125.015680 Prediction \n", + "115 138.000000 Ground‑truth \n", + "116 137.802072 Prediction \n", + "117 136.000000 Ground‑truth \n", + "118 136.000000 Ground‑truth \n", + "119 136.036170 Prediction \n", + "120 133.000000 Ground‑truth \n", + "121 133.070936 Prediction \n", + "122 132.000000 Ground‑truth \n", + "123 132.631500 Prediction \n", + "124 136.000000 Ground‑truth \n", + "125 135.916970 Prediction \n", + "126 133.000000 Ground‑truth \n", + "127 132.604088 Prediction \n", + "128 144.000000 Ground‑truth \n", + "129 144.476476 Prediction \n", + "130 152.000000 Ground‑truth \n", + "131 151.991461 Prediction \n", + "132 148.000000 Ground‑truth \n", + "133 148.640722 Prediction \n", + "134 161.000000 Ground‑truth \n", + "135 160.495288 Prediction \n", + "136 158.000000 Ground‑truth \n", + "137 158.049144 Prediction \n", + "138 157.000000 Ground‑truth \n", + "139 156.086288 Prediction \n", + "140 170.000000 Ground‑truth \n", + "141 169.994269 Prediction \n", + "142 168.000000 Ground‑truth \n", + "143 167.970161 Prediction \n", + "144 177.000000 Ground‑truth \n", + "145 178.021792 Prediction \n", + "146 176.000000 Ground‑truth \n", + "147 176.023153 Prediction \n", + "148 186.000000 Ground‑truth \n", + "149 186.004737 Prediction \n", + "150 183.000000 Ground‑truth \n", + "151 182.833664 Prediction \n", + "152 185.000000 Ground‑truth \n", + "153 185.360091 Prediction \n", + "154 180.000000 Ground‑truth \n", + "155 184.075593 Prediction \n", + "156 181.313234 Prediction \n", + "157 191.034707 Prediction \n", + "158 191.000000 Ground‑truth \n", + "159 190.978370 Prediction \n", + "160 192.000000 Ground‑truth \n", + "161 192.429357 Prediction \n", + "162 188.000000 Ground‑truth \n", + "163 188.188789 Prediction \n", + "164 200.000000 Ground‑truth \n", + "165 199.967112 Prediction \n", + "166 200.011327 Prediction \n", + "167 198.000000 Ground‑truth \n", + "168 198.039326 Prediction \n", + "169 203.000000 Ground‑truth \n", + "170 202.918840 Prediction \n", + "171 202.993100 Prediction \n", + "172 200.000000 Ground‑truth \n", + "173 200.037438 Prediction \n", + "174 207.000000 Ground‑truth \n", + "175 208.070233 Prediction \n", + "176 204.000000 Ground‑truth \n", + "177 210.000000 Ground‑truth \n", + "178 209.675816 Prediction \n", + "179 214.000000 Ground‑truth \n", + "180 213.991127 Prediction \n", + "181 214.071126 Prediction \n", + "182 217.000000 Ground‑truth \n", + "183 217.053410 Prediction \n", + "184 214.000000 Ground‑truth \n", + "185 214.012159 Prediction \n", + "186 223.084970 Prediction \n", + "187 226.000000 Ground‑truth \n", + "188 221.132467 Prediction \n", + "189 221.000000 Ground‑truth \n", + "190 233.000000 Ground‑truth \n", + "191 232.986823 Prediction \n", + "192 233.000000 Ground‑truth \n", + "193 232.970050 Prediction \n", + "194 239.000000 Ground‑truth \n", + "195 238.969714 Prediction \n", + "196 242.000000 Ground‑truth \n", + "197 242.257102 Prediction \n", + "198 243.000000 Ground‑truth \n", + "199 244.103247 Prediction \n", + "200 248.000000 Ground‑truth \n", + "201 247.921868 Prediction \n", + "202 251.000000 Ground‑truth \n", + "203 250.948474 Prediction " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# ─── constants (must match your pipeline) ───────────────────────\n", + "STRIDE = 8\n", + "RF_SIZE = 8\n", + "OFFSET = RF_SIZE // 2 # 4\n", + "K = y_labels.shape[-2] # max_hits\n", + "# ────────────────────────────────────────────────────────────────\n", + "\n", + "def frame_to_df(lbl_tensor, tag, p_thresh=0.0):\n", + " \"\"\"\n", + " lbl_tensor : (GRID,GRID,K,3) [p,nx,ny]\n", + " tag : \"GT\" | \"Pred\" label for output table\n", + " \"\"\"\n", + " \n", + " r, c, k = np.where(lbl_tensor[...,0] >= p_thresh)\n", + "\n", + " \n", + " p = lbl_tensor[r, c, k, 0]\n", + " nx = lbl_tensor[r, c, k, 1]\n", + " ny = lbl_tensor[r, c, k, 2]\n", + "\n", + " \n", + " x0 = c*STRIDE - OFFSET\n", + " y0 = r*STRIDE - OFFSET\n", + " x_px = x0 + nx*RF_SIZE\n", + " y_px = y0 + ny*RF_SIZE\n", + "\n", + " return pd.DataFrame({\n", + " \"grid_r\": r, \"grid_c\": c, \"slot\": k,\n", + " \"p\": p, \"nx\": nx, \"ny\": ny,\n", + " \"x_px\": x_px, \"y_px\": y_px,\n", + " \"tag\": tag\n", + " })\n", + "\n", + "\n", + "frame_id = idx \n", + "gt_tensor = y_labels[frame_id] \n", + "X_images_to_be_predicted = X_images[frame_id,...,0] \n", + "pred_tensor = model.predict(\n", + " X_images_to_be_predicted[None], verbose=0\n", + " )[0] \n", + "\n", + "df_gt = frame_to_df(gt_tensor, \"Ground‑truth\", p_thresh=0.1)\n", + "df_pred = frame_to_df(pred_tensor,\"Prediction\", p_thresh=0.5)\n", + "\n", + "df_frame = pd.concat([df_gt, df_pred]).sort_values(\n", + " [\"grid_r\",\"grid_c\",\"slot\",\"tag\"]\n", + " ).reset_index(drop=True)\n", + "import pandas as pd\n", + "\n", + "\n", + "pd.set_option(\"display.max_rows\", None) \n", + "pd.set_option(\"display.max_columns\", None)\n", + "pd.set_option(\"display.width\", 0) \n", + "\n", + "\n", + "# inspect\n", + "print(f\"Frame {frame_id} — {len(df_gt)} GT hits, {len(df_pred)} predictions\")\n", + "display(df_frame) " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ObjectDetection2", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Electron Counting Extended Arch/weekend steps custom loss copy.ipynb b/Electron Counting Extended Arch/weekend steps custom loss copy.ipynb index 8bb2f0a..f697a3c 100644 --- a/Electron Counting Extended Arch/weekend steps custom loss copy.ipynb +++ b/Electron Counting Extended Arch/weekend steps custom loss copy.ipynb @@ -1813,7 +1813,7 @@ ], "metadata": { "kernelspec": { - "display_name": "electrondetection", + "display_name": "objectdetection", "language": "python", "name": "python3" }, diff --git a/Electron Counting Tiling approach/16 by 16 images.ipynb b/Electron Counting Tiling approach/16 by 16 images.ipynb new file mode 100644 index 0000000..c03f9d2 --- /dev/null +++ b/Electron Counting Tiling approach/16 by 16 images.ipynb @@ -0,0 +1,1427 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:10:26.101383: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-12 18:10:26.114214: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-12 18:10:26.127106: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-12 18:10:26.131034: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-12 18:10:26.142184: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-12 18:10:26.766239: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:10:31.133749: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-12 18:10:31.135247: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79196 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-12 18:10:31.136607: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import h5py\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " return images, centers\n", + "\n", + " def sort_centers(self, centers):\n", + " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [hits_per_tile[i] for i in range(len(tiles))]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " \"\"\"\n", + " Pads or truncates the hit coordinates for each tile to a fixed size (max_hits_per_tile).\n", + " \"\"\"\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + " return np.array(padded_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + "\n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_centers = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_centers, train_size=train_size, random_state=random_state)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/40KFixed_Mixed_5_16by16_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_885344/1698765166.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + "\n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images and centers\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile * 2) # Flatten hit locations\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "# Flatten the training and validation datasets\n", + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "val_images_flat, val_centers_flat = flatten_dataset(val_images, val_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Create TensorFlow datasets from the flattened data\n", + "batch_size = 1000\n", + "train_dataset_flat = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "val_dataset_flat = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "\n", + "def visualize_random_tiles(dataset, tile_size=8, max_hits_per_tile=5, image_count=1):\n", + " \"\"\"\n", + " Visualizes a specified number of random tiled images from the TensorFlow dataset with hit locations.\n", + "\n", + " Parameters:\n", + " - dataset: tf.data.Dataset, the dataset to visualize (train or val).\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_tile: int, the maximum number of hits per tile.\n", + " - image_count: int, the number of random images to visualize from the dataset.\n", + " \"\"\"\n", + " # Take one batch from the dataset\n", + " for images, centers in dataset.take(1):\n", + " images_np = images.numpy() # Shape: (num_tiles * num_images, tile_size, tile_size, 1)\n", + " centers_np = centers.numpy() # Shape: (num_tiles * num_images, max_hits_per_tile * 2)\n", + " \n", + " # Determine the number of images in the batch\n", + " num_images = images_np.shape[0] // 8 # Assuming 16 tiles per image for a 4x4 grid\n", + " \n", + " # Select random image indices\n", + " random_indices = random.sample(range(num_images), min(image_count, num_images))\n", + "\n", + " # Visualize the selected random images\n", + " for img_idx in random_indices:\n", + " fig, axs = plt.subplots(2, 2, figsize=(8, 8))\n", + " fig.suptitle(f\"Tiled Image with Electron Hits (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " tile_image = images_np[img_idx * 8 + tile_idx].reshape(tile_size, tile_size)\n", + " tile_centers = centers_np[img_idx * 8 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Plot the tile image\n", + " ax.imshow(tile_image, cmap='gray')\n", + "\n", + " # Plot valid hits\n", + " for (x, y) in tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='x', s=30)\n", + "\n", + " ax.axis('on')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:10:50.942743: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" + ] + } + ], + "source": [ + "visualize_random_tiles(val_dataset_flat, tile_size=8, max_hits_per_tile=5, image_count=2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "def build_model(tile_size=8, max_hits_per_tile=5):\n", + " \"\"\"\n", + " Builds a CNN model for predicting electron hit coordinates in each tile.\n", + "\n", + " Parameters:\n", + " - tile_size: int, the size of each tile (e.g., 8x8).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + "\n", + " Returns:\n", + " - model: tf.keras.Model, the compiled TensorFlow model.\n", + " \"\"\"\n", + " input_shape = (tile_size, tile_size, 1)\n", + " output_units = max_hits_per_tile * 2 # x, y coordinates for each hit\n", + "\n", + " model = tf.keras.Sequential([\n", + " # Convolutional layers to extract spatial features\n", + " tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + " tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " # tf.keras.layers.MaxPooling2D((2, 2)),\n", + " \n", + " # Flatten and fully connected layers for predicting coordinates\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(128, activation='relu'),\n", + " tf.keras.layers.Dense(output_units, activation='sigmoid') # Sigmoid to keep values between 0 and 1\n", + " ])\n", + " \n", + " \n", + " return model\n", + "\n", + "# Define parameters\n", + "tile_size = 8\n", + "max_hits_per_tile = 5\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort both y_true and y_pred based on Euclidean distances\n", + " y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + " y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + " # Compute the difference\n", + " diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"sequential\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 32)       │           320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 32)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        18,496 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 10)             │         1,290 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m1,290\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 28,426 (111.04 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m28,426\u001b[0m (111.04 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 28,426 (111.04 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m28,426\u001b[0m (111.04 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with strategy.scope():\n", + " # Instantiate the model\n", + " model = build_model(tile_size=tile_size, max_hits_per_tile=max_hits_per_tile)\n", + " # model.compile(optimizer='adam', loss=euclidean_sorted_custom_loss(exponent=2))\n", + " model.compile(optimizer='adam', loss='mse')\n", + " model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:31.894097: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-12 18:11:31.902543: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-12 18:11:31.923252: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731435091.986247 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435091.988696 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435091.989369 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.046992 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.047087 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.047237 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.047584 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.047595 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.047770 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.053386 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.053401 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.053402 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.071414 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.071559 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.071584 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.074068 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.074105 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.074375 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.074787 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.074826 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.075014 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.075137 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.075290 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.075423 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.077400 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.077448 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.077458 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.094512 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.094633 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.094640 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.094858 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.095100 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.095115 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.095202 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.095623 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.095630 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.095635 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.096001 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.096126 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.096198 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.096311 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.096577 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.096586 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.096950 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.096961 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.098565 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.098640 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.098645 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.101602 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.101740 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.101751 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.103741 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.103884 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.103895 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.105942 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.106050 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.106060 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.108332 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.108474 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.108482 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.110325 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.110455 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.110464 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.111200 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.112059 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.112078 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.112183 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.120468 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.120508 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.120579 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.122708 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.122702 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.122732 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.203652 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.203674 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.204031 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.204107 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.204268 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.204439 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.204605 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.204704 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.204871 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.205037 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.205194 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.205344 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.205505 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.205666 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.205824 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.205964 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.206640 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.206715 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.206885 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.207034 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.207758 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.207833 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.208026 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.208127 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.208289 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.208443 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.208609 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.208751 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.210131 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.210197 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.211270 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.211356 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.211535 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.211690 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.211840 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.211991 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.212163 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.212319 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.212466 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.212623 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.212781 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.212939 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.213096 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.213235 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.214625 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.214696 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.214972 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.215057 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.215234 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.215321 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.220956 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.220953 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.221295 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.221300 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.221605 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.221607 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.222326 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.222392 885752 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.462712 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.463994 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.464220 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.465394 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.466170 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.466181 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.466745 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.466764 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.467096 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.467112 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.467324 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.467537 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.467748 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.467960 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.468216 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.469190 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.469362 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.469542 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.469839 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.470075 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.470339 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.470554 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.471763 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.472256 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.472361 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.472926 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.473268 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.473490 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.474760 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.474987 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.475214 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.476566 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.476559 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.477643 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.477729 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.477740 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.478231 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.478232 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.478550 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.479039 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.479030 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.479230 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.480050 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.480055 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.480580 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.480598 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.480959 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.481231 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.481471 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.481589 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.482483 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.482717 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.482729 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.484176 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.484400 885733 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.484459 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.484592 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.484838 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.485006 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.485514 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.485522 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.485776 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.486247 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.486260 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.488694 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.488863 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.489133 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.489365 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.489600 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.490174 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.490276 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.490659 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.490905 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.492373 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.492386 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.493136 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.493150 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.493627 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.493642 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.493902 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.494324 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.494594 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.495504 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.495515 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.523418 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.524212 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.525149 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.525572 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.526401 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.526497 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.528228 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.528238 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.528778 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.528790 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.529249 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.529261 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.530976 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.530988 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.532255 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.532266 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.532800 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.532814 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.533636 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.533648 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.535399 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.535414 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.536206 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.536220 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.536970 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.536988 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.538507 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.538521 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.539262 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.539271 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.554688 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.554711 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.555206 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.555223 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.555680 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.555692 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.556160 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.556175 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.556624 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.556636 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.557649 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.557662 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.559261 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.559272 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.559748 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.559763 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.560282 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.560379 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.560773 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.560962 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.561144 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.561333 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.561516 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.561625 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.566324 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.566430 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.567022 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.567127 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.567399 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.567597 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.567795 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.567901 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.568242 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.568348 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.568721 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.568869 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.569455 885737 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.569563 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m19/32\u001b[0m \u001b[32m━━━━━━━━━━━\u001b[0m\u001b[37m━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.1977" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731435092.688879 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.689340 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.689559 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.689964 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.690201 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.690424 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.690901 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.691122 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.691623 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.692953 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.693188 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.693511 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.693731 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.693955 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.694461 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.694719 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.694941 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.695174 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.695462 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.695916 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.696151 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.696570 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.697014 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.697257 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.697506 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.698194 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.698595 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.705738 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.707098 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.707598 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.708070 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.708373 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.708594 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.709037 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.709456 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.709763 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.710154 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.710636 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.710942 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.711241 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.711737 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.712038 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.718938 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.719208 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.719447 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.719698 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.719933 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.720287 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.720707 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.720952 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.721350 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.721743 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.721985 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.722220 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.723330 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.723913 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.724185 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.724407 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.724751 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.725179 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435092.725825 885751 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m26/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━━━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.1903" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:32.986289: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-12 18:11:32.986376: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731435093.911630 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.914439 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.914687 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.914906 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.915148 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.915363 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.915540 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.916036 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.916390 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.916538 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.916731 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.916786 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.917512 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.917659 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.917936 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.918172 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.918188 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.918574 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.918770 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.918862 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.919226 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.919241 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.919386 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.919677 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.919853 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.920003 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.920184 885750 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.920352 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.920525 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.920914 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.921089 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.921303 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.921501 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.921781 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.921972 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.922199 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.922360 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.922624 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.922861 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.923445 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.924021 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.924134 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.924389 885743 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.924555 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731435093.925029 885739 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 48ms/step - loss: 0.1812 - val_loss: 0.0489\n", + "Epoch 2/50\n", + "\u001b[1m 1/32\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 151ms/step - loss: 0.0490" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:34.204000: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0470 - val_loss: 0.0441\n", + "Epoch 3/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:34.562151: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0434 - val_loss: 0.0423\n", + "Epoch 4/50\n", + "\u001b[1m13/32\u001b[0m \u001b[32m━━━━━━━━\u001b[0m\u001b[37m━━━━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 5ms/step - loss: 0.0416 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:35.142192: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0411 - val_loss: 0.0398\n", + "Epoch 5/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0371 - val_loss: 0.0346\n", + "Epoch 6/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0305 - val_loss: 0.0274\n", + "Epoch 7/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:36.454273: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0253 - val_loss: 0.0230\n", + "Epoch 8/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0218 - val_loss: 0.0204\n", + "Epoch 9/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 28ms/step - loss: 0.0195 - val_loss: 0.0184\n", + "Epoch 10/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0175 - val_loss: 0.0165\n", + "Epoch 11/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0156 - val_loss: 0.0148\n", + "Epoch 12/50\n", + "\u001b[1m10/32\u001b[0m \u001b[32m━━━━━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 6ms/step - loss: 0.0143 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:39.784502: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0140 - val_loss: 0.0134\n", + "Epoch 13/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0128 - val_loss: 0.0122\n", + "Epoch 14/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0118 - val_loss: 0.0113\n", + "Epoch 15/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0111 - val_loss: 0.0107\n", + "Epoch 16/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0106 - val_loss: 0.0103\n", + "Epoch 17/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0102 - val_loss: 0.0100\n", + "Epoch 18/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 31ms/step - loss: 0.0099 - val_loss: 0.0098\n", + "Epoch 19/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0097 - val_loss: 0.0096\n", + "Epoch 20/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0095 - val_loss: 0.0094\n", + "Epoch 21/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0094 - val_loss: 0.0093\n", + "Epoch 22/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0093 - val_loss: 0.0092\n", + "Epoch 23/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:45.590460: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0091 - val_loss: 0.0091\n", + "Epoch 24/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0090 - val_loss: 0.0090\n", + "Epoch 25/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0089 - val_loss: 0.0089\n", + "Epoch 26/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0089 - val_loss: 0.0089\n", + "Epoch 27/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 29ms/step - loss: 0.0088 - val_loss: 0.0088\n", + "Epoch 28/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0087 - val_loss: 0.0087\n", + "Epoch 29/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0086 - val_loss: 0.0087\n", + "Epoch 30/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0086 - val_loss: 0.0086\n", + "Epoch 31/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0085 - val_loss: 0.0086\n", + "Epoch 32/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0084 - val_loss: 0.0085\n", + "Epoch 33/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0084 - val_loss: 0.0085\n", + "Epoch 34/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0083 - val_loss: 0.0084\n", + "Epoch 35/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0083 - val_loss: 0.0084\n", + "Epoch 36/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 30ms/step - loss: 0.0083 - val_loss: 0.0084\n", + "Epoch 37/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0082 - val_loss: 0.0083\n", + "Epoch 38/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 0.0082 - val_loss: 0.0083\n", + "Epoch 39/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0081 - val_loss: 0.0082\n", + "Epoch 40/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0081 - val_loss: 0.0082\n", + "Epoch 41/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 24ms/step - loss: 0.0081 - val_loss: 0.0082\n", + "Epoch 42/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 13ms/step - loss: 0.0080 - val_loss: 0.0081\n", + "Epoch 43/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0080 - val_loss: 0.0081\n", + "Epoch 44/50\n", + "\u001b[1m 1/32\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 139ms/step - loss: 0.0081" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-12 18:11:57.963007: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 30ms/step - loss: 0.0080 - val_loss: 0.0081\n", + "Epoch 45/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - loss: 0.0079 - val_loss: 0.0081\n", + "Epoch 46/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0079 - val_loss: 0.0080\n", + "Epoch 47/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0079 - val_loss: 0.0080\n", + "Epoch 48/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - loss: 0.0078 - val_loss: 0.0080\n", + "Epoch 49/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step - loss: 0.0078 - val_loss: 0.0079\n", + "Epoch 50/50\n", + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 14ms/step - loss: 0.0078 - val_loss: 0.0079\n" + ] + } + ], + "source": [ + "# Train the model with the flattened dataset\n", + "history = model.fit(\n", + " train_dataset_flat,\n", + " validation_data=val_dataset_flat,\n", + " epochs=50, \n", + " verbose=1\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import random\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_predictions_with_original(model, dataset, tile_size=8, max_hits_per_tile=5, num_images=1, threshold=0.1):\n", + " \"\"\"\n", + " Visualizes the model's predictions on a random sample of images from the dataset,\n", + " showing both the original image and tiled predictions.\n", + "\n", + " Parameters:\n", + " - model: tf.keras.Model, the trained model to make predictions.\n", + " - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - num_images: int, number of random images to visualize.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \"\"\"\n", + " # Take one batch from the dataset for prediction\n", + " images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + " # Randomly select indices of images to visualize\n", + " indices = random.sample(range(images.shape[0] // 4), num_images)\n", + "\n", + " # Make predictions on the batch\n", + " predictions = model.predict(images)\n", + "\n", + " # Visualize the selected images\n", + " for img_idx in indices:\n", + " # Reconstruct the original image from tiles\n", + " tiles = images[img_idx * 4 : (img_idx + 1) * 4]\n", + " reconstructed_image = reconstruct_image_from_tiles(tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 2) # Assuming 2x2 tiles for 4 tiles per image\n", + "\n", + " # Plot the original image with overlayed predictions\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + " # Overlay true and predicted centers on the original image\n", + " for tile_idx in range(4): # Assuming 2x2 tiles\n", + " row_offset = (tile_idx // 2) * tile_size\n", + " col_offset = (tile_idx % 2) * tile_size\n", + "\n", + " # Get true and predicted centers for each tile\n", + " true_tile_centers = true_centers[img_idx * 4 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 4 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Plot true hits in green\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted hits in red, with threshold check\n", + " for (x, y) in predicted_tile_centers:\n", + " # Ignore (0, 0) or predictions close to it\n", + " if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + " # Now plot the tiled images with predictions\n", + " fig, axs = plt.subplots(2, 2, figsize=(6, 6))\n", + " fig.suptitle(f\"Tiled Predictions (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " true_tile_centers = true_centers[img_idx * 4 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 4 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Display the tile\n", + " ax.imshow(images[img_idx * 4 + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + " # Plot true centers\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted centers with threshold check\n", + " for (x, y) in predicted_tile_centers:\n", + " # Ignore (0, 0) or predictions close to it\n", + " if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " ax.axis('off')\n", + "\n", + " handles, labels = axs[0, 0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAJWCAYAAABF67MAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9tElEQVR4nO3dfVyV9eH/8fcBAbnRgzcgWqCQZimai1xpW6BmhhpfWebXUhM1b77LvFn8nI8tk7RyOjMpa5ptisy7daM2FzbdQtNmK7QmTpNEA7O8m2IK3gDX7w87Zxy5+4DcHPT1fDx41Lmuw3U+HI+Hl5/r5tgsy7IEAACACnnU9wAAAAAaAqIJAADAANEEAABggGgCAAAwQDQBAAAYaFTfAwAAoK4UFRXp8uXL9T0MuCkvLy95enqWu55oAgBc9yzL0nfffaczZ87U91Dg5gIDAxUSEiKbzVZqHdEEALjuOYIpODhYfn5+Zf5CxI3Nsizl5+fr+PHjkqTWrVuXug/RBAC4rhUVFTmDqUWLFvU9HLgxX19fSdLx48cVHBxcalcdB4IDAK5rjmOY/Pz86nkkaAgcr5Oyjn0jmgAANwR2ycFERa8TogkAAMAA0QQAAK5ZUlKSunXrVt/DqFVEEwAAbsZms1X4lZSUVGdjiYmJ0ZQpU0otX758uQIDA523ExMT9be//c15OyEhQYMGDar9AdYhognXnYSEBLVr185lWU2/yaSnp8tmsyk9Pb3Gtllb2rVrp4SEBOft2hh7Xb+JV1VxcbEiIyP1wgsv1PdQGrxTp07J399f77//fn0Ppc6kZaUpNy+3zHW5eblKy0qr8cf89ttvnV8LFy5U06ZNXZYlJiY672tZlgoLC2t8DFUVEBBw3Z+dSDShQajsX12OL3eLmOXLl7uMr3Hjxrr11ls1ceJEHTt2rL6HVyXvv/++W4dRRVavXq3c3FxNnDjRuczxZ/PZZ5/V48hqV0FBgcaMGaPIyEjZ7XYFBATojjvuUHJycplnBmVkZGjgwIEKCQlRQECAunbtqldeeUVFRUXO+7Ro0UJPPPGEZsyYUZc/Sr1Jy0pT3Jo4xaTElAqn3LxcxaTEKG5NXI2HU0hIiPPLbrfLZrM5b+/fv19NmjRRWlqaoqKi5OPjo+3bt5c5szNlyhTFxMQ4bxcXF2vOnDkKDw+Xr6+v7rjjDr399ts1MuaSu+eSkpKUkpKiDRs2uO37c3VwnSY0CKmpqS63V6xYoc2bN5dafvvtt2vp0qUqLi6uy+FVatasWQoPD9eFCxe0fft2/e53v9P777+vzMzMOj8N+r777lNBQYG8vb2r9H3vv/++XnvttTLDqaCgQI0aue/byW9/+1sNHTpUdru9vodSpwoKCrR37171799f7dq1k4eHhz7++GNNnTpVn3zyiVatWuW8b0ZGhnr27KkOHTrol7/8pfz8/JSWlqbJkyfr4MGDSk5Odt53woQJeuWVV/T3v/9dvXv3ro8frc5EBkcqzB6m7NPZikmJUfrIdIXaQ53BlH06WxHNIhQZHFnnY5s+fbrmz5+viIgINWvWzOh75syZoz/+8Y9avHixOnTooG3btmn48OEKCgpSdHR0jY0tMTFR+/bt09mzZ7Vs2TJJUvPmzWts+/XFfd/lgBKGDx/ucnvnzp3avHlzqeXuKjY2VnfddZck6YknnlCLFi20YMECbdiwQY8++miZ33P+/Hn5+/vX+Fg8PDzUuHHjGt1mTW+vJu3evVtffPGFXnrppfoeSp1r3ry5du7c6bJswoQJstvtWrRokRYsWKCQkBBJ0pIlSyRJ27Ztc/5yGz9+vKKjo7V8+XKXaLr99tsVGRmp5cuXX/fRFGoPVfrIdGcgxaTEKDU+VSPWjXAGkyOk6tqsWbPUt29f4/tfvHhRL774orZs2aIePXpIkiIiIrR9+3YtWbKkwmh6/fXX9eabb7osKywsLPfvfkBAgHx9fXXx4kXna+x6wO45XHfKOqapLN98841Gjx6tVq1aycfHR507d9Yf/vCHUvc7cuSIBg0aJH9/fwUHB2vq1Km6ePHiNY3R8Yvm0KFDzjEHBATo4MGD6t+/v5o0aaJhw4ZJujKdvnDhQnXu3FmNGzdWq1atNH78eJ0+fdplm5Zl6fnnn9fNN98sPz8/9erVS3v37i312OUd0/TJJ5+of//+atasmfz9/dW1a1fnL8qEhAS99tprklx3lTqUdUzT7t27FRsbq6ZNmyogIEB9+vQp9QvcsYtsx44d+sUvfqGgoCD5+/srPj5eJ06ccLnvZ599pn79+qlly5by9fVVeHi4Ro8eXelzvX79enl7e+u+++6r9L6OP4ecnBwNHDhQAQEBuummm5w/+549e9S7d2/5+/urbdu2LjM1kvSf//xHiYmJ6tKliwICAtS0aVPFxsbqiy++KPVYX3/9teLi4lxeVx988EG5fzYPPvig7Ha7/Pz8FB0drR07dlT685TH8fej5OewnT17Vo0bN3Y5sFe68lESjqskl9S3b1/9+c9/lmVZ1R5HQ+EIp4hmEco+na17/3BvvQeTJOc/xEx99dVXys/PV9++fRUQEOD8WrFihQ4ePFjh9w4bNkyff/65y9esWbOuZfgNEjNNuCEdO3ZM99xzj2w2myZOnKigoCClpaVpzJgxOnv2rPNMkYKCAvXp00c5OTmaNGmS2rRpo9TUVP3973+/psd3vEGVPGiysLBQ/fr1009+8hPNnz/fudtu/PjxWr58uUaNGqVJkybp0KFDWrRokXbv3q0dO3bIy8tLkvTss8/q+eefV//+/dW/f3/t2rVLDzzwgC5dulTpeDZv3qyBAweqdevWmjx5skJCQrRv3z5t3LhRkydP1vjx43X06NEyd4mWZe/evfrpT3+qpk2batq0afLy8tKSJUsUExOjrVu36u6773a5/1NPPaVmzZpp5syZOnz4sBYuXKiJEydq7dq1kq58pMEDDzygoKAgTZ8+XYGBgTp8+LDefffdSsfy8ccfKzIy0vk8VaaoqEixsbG67777NG/ePK1cuVITJ06Uv7+/fv3rX2vYsGH62c9+psWLF+vxxx9Xjx49FB4eLknKzs7W+vXr9cgjjyg8PFzHjh1z/gv+3//+t9q0aSPpyixi79699e233zqf71WrVunDDz8sNZ6///3vio2NVVRUlGbOnCkPDw8tW7ZMvXv31kcffaQf//jHlf5Mly5d0tmzZ1VQUKDPPvtM8+fPV9u2bdW+fXvnfWJiYrR27VqNHz9ev/jFL5y7595991399re/LbXNqKgovfzyy9q7d68iI+t+11RdC7WHKjU+Vff+4V7nstT41HoLJkmlZqI9PDxKRWzJY9fOnTsnSfrLX/6im266yeV+Pj4+FT6W3W53eb1IUnBwcJXH3OBZQAP05JNPWuW9fEeOHGm1bdvWZZkka+bMmc7bY8aMsVq3bm2dPHnS5X5Dhw617Ha7lZ+fb1mWZS1cuNCSZP3pT39y3uf8+fNW+/btLUnWhx9+WOE4ly1bZkmytmzZYp04ccLKzc211qxZY7Vo0cLy9fW1jhw54hyzJGv69Oku3//RRx9ZkqyVK1e6LN+0aZPL8uPHj1ve3t7WgAEDrOLiYuf9fvWrX1mSrJEjRzqXffjhhy5jLywstMLDw622bdtap0+fdnmcktuq6Dm/+vkdNGiQ5e3tbR08eNC57OjRo1aTJk2s++67r9Tzc//997s81tSpUy1PT0/rzJkzlmVZ1rp16yxJ1qefflrm41fk5ptvth5++OFSyx2PXXKbjj+HF1980bns9OnTlq+vr2Wz2aw1a9Y4l+/fv7/Uz33hwgWrqKjI5XEOHTpk+fj4WLNmzXIue+mllyxJ1vr1653LCgoKrNtuu83lz6a4uNjq0KGD1a9fP5fnJz8/3woPD7f69u1r9BysXr3akuT8uuuuu6x//etfLvcpLCy0Jk6caHl5eTnv5+npaf3ud78rc5sff/yxJclau3at0RjqU0FBgfXvf//bKigoqPY2cs7kWBHJEZaS5PyKSI6wcs7k1OBIy7Zs2TLLbrc7bzv+Dl/993XatGlW9+7dXZb17NnTio6OtizLss6ePWv5+PhYK1asqNLjR0dHW5MnT650XDNnzrTuuOMO5+2xY8daAwcOrNJjuYOKXi/snsMNx7IsvfPOO3rooYdkWZZOnjzp/OrXr5/y8vK0a9cuSVcOfm7durUGDx7s/H4/Pz+NGzeuSo95//33KygoSKGhoRo6dKgCAgK0bt26Uv/a+7//+z+X22+99Zbsdrv69u3rMs6oqCgFBAQ4Zya2bNmiS5cu6amnnnLZbVbWtVWutnv3bh06dEhTpkwptWumOh87UVRUpL/+9a8aNGiQIiIinMtbt26txx57TNu3b9fZs2ddvmfcuHEuj/XTn/5URUVF+vrrryXJOa6NGzeWedZXRU6dOmV8kKzDE0884fz/wMBAdezYUf7+/hoyZIhzeceOHRUYGKjs7GznMh8fH3l4XHlbLSoq0qlTpxQQEKCOHTs6X1OStGnTJt10002Ki4tzLmvcuLHGjh3rMo7PP/9cWVlZeuyxx3Tq1Cnnn//58+fVp08fbdu2zeikh169emnz5s166623NGHCBHl5een8+fMu9/H09NQtt9yifv36KSUlRWvXrtVDDz2kp556SuvXry+1TcdzevLkyUofv6G7+qDvHaN3OHfVlXVWXX3p3bu3PvvsM61YsUJZWVmaOXOmMjMzneubNGmixMRETZ06VSkpKTp48KB27dqlV199VSkpKTU+nnbt2ulf//qXvvzyS508ebLKf3fdEbvncMM5ceKEzpw5ozfeeENvvPFGmfc5fvy4pCvHnbRv375UPHTs2LFKj/naa6/p1ltvVaNGjdSqVSt17NjR+cvVoVGjRrr55ptdlmVlZSkvL6/cafCS45SkDh06uKwPCgqqNBgcuwprahfLiRMnlJ+fX+ZzdPvtt6u4uFi5ubnq3Lmzc3lYWJjL/Rxjdhy3FR0drYcffljPPfecXn75ZcXExGjQoEF67LHHKt2tIKlKx900btxYQUFBLsvsdrtuvvnmUq8Du93ucmxZcXGxkpOT9frrr+vQoUOlTtV3+Prrr3XLLbeU2t7Vuz+ysrIkSSNHjix3vHl5eZX+Gbdq1UqtWrWSJA0ePFgvvvii+vbtq6ysLOdBur/5zW+UnJysrKwsBQQESJKGDBmiXr166cknn9TAgQNdzpB0PKfX++e5XR1MjmOYrj44vD6PbXLo16+fZsyYoWnTpunChQsaPXq0Hn/8ce3Zs8d5n9mzZysoKEhz5sxRdna2AgMDdeedd+pXv/pVjY9n7NixSk9P11133aVz587pww8/dLn8QUNENOGG4/iX+fDhw8v9ZdS1a9cafcwf//jHlR60WXKWwqG4uFjBwcFauXJlmd9z9S/3hsrT07PM5SV/Mb/99tvauXOn/vznP+uDDz7Q6NGj9dJLL2nnzp3OX/JladGiRamD5qszlsrGKEkvvviiZsyYodGjR2v27Nlq3ry5PDw8NGXKlGpdBsPxPb/97W/L/XiKin728gwePFi//vWvtWHDBo0fP17SlbOjevfuXWp7cXFx+sUvfqHDhw+7RJ3jOW3ZsmWVH78hyTyeqZy8nFIHfZcMp5y8HGUez6y1aEpISHC5QG1MTEy5/xB47rnn9Nxzz5W7LZvNpsmTJ2vy5MnGj1/e9ZWuHldSUpLLCSFBQUH661//avw4DQHRhBtOUFCQmjRpoqKiIt1///0V3rdt27bKzMyUZVku/6L+8ssva3uYkqRbbrlFW7Zs0b333lvmGUwObdu2lXRlZqLkLrETJ05UGgy33HKLJCkzM7PC58N0RiEoKEh+fn5lPkf79++Xh4eHQkOr98vlnnvu0T333KMXXnhBq1at0rBhw7RmzRqX3WlXu+2225xnKda2t99+W7169dLvf/97l+VnzpxxiYu2bdvq3//+d6nX1VdffeXyfY4/m6ZNm1b6Wq2KgoICSVdmqRyOHTvmMjPm4NilcvUVpx3P6e23315j43JHsR1i9d7Q9xQZHFkqihzhlHk8U7EdYutphKhLHNOEG46np6cefvhhvfPOOy77+x1Knurev39/HT161OWKufn5+eXu1qtpQ4YMUVFRkWbPnl1qXWFhofOU8fvvv19eXl569dVXXf4FunDhwkof484771R4eLgWLlzocgq65DqL4jhT5+r7XM3T01MPPPCANmzYoMOHDzuXHzt2TKtWrdJPfvITNW3atNJxlXT69OlS/7J2zLxUdvmHHj16KDMz85ovE2HC09Oz1DjfeustffPNNy7L+vXrp2+++Ubvvfeec9mFCxe0dOlSl/tFRUXplltu0fz5851nPpV09WUZrnby5MkyZyQc19spOft56623avPmzTp16pRzWVFRkf70pz+pSZMmzoBzyMjIkN1ud9nNer2K7RBb7ixSqD2UYLqBMNOEG9JvfvMbffjhh7r77rs1duxYderUSf/5z3+0a9cubdmyRf/5z38kXdknv2jRIj3++OPKyMhQ69atlZqaWmdX8Y6Ojtb48eM1Z84cff7553rggQfk5eWlrKwsvfXWW0pOTtbgwYMVFBSkxMREzZkzRwMHDlT//v21e/dupaWlVbr7xMPDQ7/73e/00EMPqVu3bho1apRat26t/fv3a+/evfrggw8kXfkFLkmTJk1Sv3795OnpqaFDh5a5zeeff16bN2/WT37yE/385z9Xo0aNtGTJEl28eFHz5s2r8vOQkpKi119/XfHx8brlllv0/fffa+nSpWratKn69+9f4ff+z//8j2bPnq2tW7fqgQceqPJjV8XAgQM1a9YsjRo1Sj179tSePXu0cuVKl9k/6cplJBYtWqRHH31UkydPVuvWrbVy5UrnhQIds08eHh568803FRsbq86dO2vUqFG66aab9M033+jDDz9U06ZN9ec//7nc8Tiu/Ow4KP/777/XBx98oM2bN+uhhx5yuTDl9OnTNXz4cN19990aN26cfH19tXr1amVkZOj5558vdckGxzau92OaABd1cv4eUMOu9ZIDlmVZx44ds5588kkrNDTU8vLyskJCQqw+ffpYb7zxhsv9vv76aysuLs7y8/OzWrZsaU2ePNl5yr/pJQcqO1V+5MiRlr+/f7nr33jjDSsqKsry9fW1mjRpYnXp0sWaNm2adfToUed9ioqKrOeee85q3bq15evra8XExFiZmZlW27ZtK7zkgMP27dutvn37Wk2aNLH8/f2trl27Wq+++qpzfWFhofXUU09ZQUFBls1mc3n+y3p+d+3aZfXr188KCAiw/Pz8rF69elkff/yx0fNz9Rh37dplPfroo1ZYWJjl4+NjBQcHWwMHDrQ+++yzip5Wp65du1pjxoyp9LHL+3OIjo62OnfuXGp527ZtrQEDBjhvX7hwwXr66aedfwb33nuv9Y9//MOKjo52nvbtkJ2dbQ0YMMDy9fW1goKCrKefftp65513LEnWzp07Xe67e/du62c/+5nVokULy8fHx2rbtq01ZMgQ629/+1uFP/enn35qPfLII87nzd/f37rzzjutBQsWWJcvXy51/02bNlnR0dFWy5YtLW9vb6tLly7W4sWLS91v3759zktpNAQ1cckB3Dgqer3YLOsGuJwrgBtaamqqnnzySeXk5JS6rII7WbhwoaZOnaojR46UuhyFO5kyZYq2bdumjIyMBjHTdOHCBR06dEjh4eFu/ZE/cA8VvV44pgnAdW/YsGEKCwtzfhyKO3AcjO1w4cIFLVmyRB06dHDrYDp16pTefPNNPf/88w0imICaxDFNAK57Hh4eZR70X59+9rOfKSwsTN26dVNeXp7++Mc/av/+/eVeXsJdtGjRosyD0oEbAdEEAPWgX79+evPNN7Vy5UoVFRWpU6dOWrNmjf73f/+3vocGoBwc0wQAuK5xTFPdSEpK0vr16/X555/X91CuCcc0AQDQgNhstgq/Sl55u7bFxMSU+TmWy5cvdzmxIjExUX/729+ctxMSEjRo0KDaH2AdYvccAABu5ttvv3X+/9q1a/Xss8+6XGW/5MfdWJaloqIil88GrA8BAQHV+lifhoSZJgAAKpCWlabcvNwy1+Xm5SotK63GHzMkJMT5ZbfbZbPZnLf379+vJk2aKC0tTVFRUfLx8dH27dvLnNmZMmWKy4fkFhcXa86cOQoPD5evr6/uuOMOl088uBZJSUnOK/UnJSUpJSVFGzZscM6OlfcZdg0JM00AAJQjLStNcWviFGYPc/nAXulKMDk+sPe9oe/V+cepTJ8+XfPnz1dERISaNWtm9D1z5sxxXim+Q4cO2rZtm4YPH66goCBFR0fX2NgSExO1b98+nT17VsuWLZMkNW/evMa2X1+IJgAAyhEZHKkwe5iyT2crJiXGGU6OYMo+na2IZhGKDI6s87HNmjVLffv2Nb7/xYsX9eKLL2rLli3q0aOHJCkiIkLbt2/XkiVLKoym119/3fmZhQ6FhYXlHlgfEBAgX19fXbx4USEhIcZjdHfsngMAoByh9lClj0xXRLMIZzh9nPuxSzBdPQNVV0p+4LKJr776Svn5+erbt6/z+KOAgACtWLFCBw8erPB7hw0bps8//9zla9asWdcy/AaJmSYAACrgCCdHKN37h3slqV6DSZL8/f1dbnt4eOjqqwhdvnzZ+f+Oi5L+5S9/KXXVeR8fnwofy263q3379i7LgoODqzzmho5oAgCgEqH2UKXGpzqDSZJS41PrLZjKEhQUVOrK959//rm8vLwkSZ06dZKPj49ycnJq9Pil8nh7e6uoqKjWH6cusXsOAIBK5OblasS6ES7LRqwbUe5ZdfWhd+/e+uyzz7RixQplZWVp5syZLhHVpEkTJSYmaurUqUpJSdHBgwe1a9cuvfrqq0pJSanx8bRr107/+te/9OWXX+rkyZMus14NFdEEAEAFrj7oe8foHS7HOLlLOPXr108zZszQtGnT1L17d33//fd6/PHHXe4ze/ZszZgxQ3PmzNHtt9+uBx98UH/5y18UHh5e4+MZO3asOnbsqLvuuktBQUHasWNHjT9GXeNjVAAA17Vr+RiVq4OpvLPn6vPYJtQsPkYFAIBqyDyeqZy8nFJhVPKsupy8HGUez6xkS7gecCA4AADliO0Qq/eGvqfI4MhSM0mOcMo8nlnnF7ZE/SCaAACoQEVBFGoPZbfcDYTdcwAAAAaIJgAAAANEEwAAgAHjY5psNlttjgNAA1OfVyvh/QhV0bZtWy1evFjnz5+v76GgllT1c/iqi5kmAAAAA0QTAACAAaIJAIAbXFJSkhITE523x48fr5deeqnOx5GRkeH8CJhrlZCQoEGDBl37oEogmgAAcENJSUnq3r27unfvrh49eig+Pl5Lly5VYWFhrT/2vHnzNGHCBKP71mTomIiLi9OqVatKLU9KSlK3bt2ct5OTk7V8+XLn7ZiYGE2ZMuWaHpuLWwIA4KZ69OihZ599VpcvX9aOHTs0b948NWrUSKNGjSp138uXL8vLy6tGHtdut9fIdupTbfwMRBMAAG7K29tbLVu2lCQNHjxY6enp+uijjzRq1CglJSXp3Llz6tSpk9566y15e3trw4YN+u6775ScnKydO3fKw8ND3bp109NPP602bdpIkoqKivTKK6/ovffek6enp+Li4ko97vjx43Xrrbfq6aefliRdunRJS5Ys0aZNm3T69Gm1atVKCQkJ6t69u3NGqnfv3pKkAQMGKCkpScXFxUpJSdH69et16tQphYWFacyYMerTp4/zcXbs2KEFCxbo2LFjioyM1IABA2rsuUtISNCZM2e0fv16JSQkaOvWrdq6dauSk5MlSYcOHVK7du2qtE2iCQCASnjk56vVqlUKWrdOXidP6nLLljoRH69jjz2mYj+/OhuHj4+P8vLynLc//fRT+fv7a9GiRZKkwsJCTZo0SV26dNHSpUvl6emp3//+95o0aZJWr14tLy8vrVy5Uhs3btSMGTMUHh6ulStXKj09vcLT9mfOnKk9e/YoMTFRHTp00NGjR3XmzBm1atVKc+fO1S9/+Uu9/fbb8vf3V+PGjSVJy5cvV1pamqZPn67Q0FDt3r1bzz77rAIDAxUVFaXvvvtO06ZN0+DBgxUfH699+/Zp4cKFtfK8JScn68CBA4qMjNSsWbMkSUFBQVXeDtEEAEAFPPLz1XH8ePkdOCBbcbEkyfv4cbVZulSBW7fqyyVLaj2cLMvSP//5T+3cuVNDhgxxLm/cuLGeeeYZ5265999/X8XFxXrmmWec1zObOXOmevXqpYyMDN1zzz1avXq1EhISnDND06dP1z/+8Y9yH/vrr7/Wli1btGjRIt19992SpJtvvtm53rEbrHnz5mrSpImkKzNTy5Yt02uvvaauXbs6v+eLL77QunXrFBUVpXfeeUc33XSTpk6dKklq166dvvrqK61YsaLS52PRokVavHix87aHh4cuXbqkTp06lXl/u90ub29v+fn5KSQkpNLtl4doAgCgAq1WrXIJJgdbcbH8DhxQq1Wr9O0TT9TKY2/fvl333XefCgsLVVxcrAcffFDjxo1zrm/fvr3LcUxZWVk6cuSIoqOjXbZz6dIlHTlyROfOndPJkyfVuXNn57pGjRqpU6dO5V6w9sCBA/L09FRUVJTxuHNzc3XhwgVNnDjRZfnly5fVsWNHSdLhw4cVGRnpst4RWJUZMWKEBg4c6LzdpUsXvfLKK9q2bZvxGKuDaAIAoAJB69aVCian4mIFrVtXa9EUFRWl6dOny8vLSy1btlSjRq6/tn19fV1uFxQU6LbbbtPs2bNLbatZs2bVGoOPj0+Vv6egoECS9PLLLys4ONhlXU0crG632xUaGuq83b59ezVv3vyat1sZogkAgAp4nTxZ7jpbJeuvla+vr0scVKZjx47avHmzmjVrpoCAgDLv07JlS+3du1d33nmnpCvHQe3bt0+33XZbmfdv3769iouLlZGR4dw9V5Ij5IqKipzLwsPD5e3trWPHjpU7Q9WuXbtSM0N79uyp/IesJm9vb5cxVgfXaQIAoAKXfzh7rSxWJevrWmxsrAIDA5WYmKjdu3frm2++UUZGhubPn69jx45JkoYOHaqUlBSlp6fr8OHDmjt3rs6dO1fuNtu0aaMBAwZo9uzZSk9Pd25z8+bNkqTWrVvLZrNp+/btOn36tPLz8+Xv76/hw4drwYIF2rhxo44cOaL9+/dr7dq12rhxoyTp4YcfVm5urpKTk3X48GFt2rTJua42tGvXTp988okOHz6skydPqri82cMKEE0AAFTgRHy8LI9yfl16eOhEfHzdDqgCjRs31pIlSxQSEqJp06ZpyJAhmj17ti5evCh/f39J0rBhwxQbG6ukpCSNHj1afn5+iomJqXC706dPV58+fTR37lw98sgjeuGFF5y74IKDgzVu3DgtWrRI/fr107x58yRJEyZM0JgxY7R8+XI98sgjmjRpkrZv3+689EFISIjmzp2rrVu3atiwYXr33Xf185//vNaem8TERHl6eqpTp04KCgpSTk5Olbdhsww/qpxPFQdQkuFbR63g/QhV0bZtWy1evNh5vaOqKnn2nIqLZdOVGSZ5eCj/1lvr5Ow5VKyiyyVU1YULF3To0CGFh4c7L5/gwEwTAAAVKPbz05dLlujo2LG6HBwsy8NDl4ODdXTsWILpBsOB4AAAVKLYz0/fPvFErZ0lh4aBmSYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAA3OCSkpKUmJjovD1+/Hi99NJLdT6OjIwMde/eXd9///01byshIUGDBg269kGVQDQBAOCGkpKS1L17d3Xv3l09evRQfHy8li5dqsLCwlp/7Hnz5mnChAlG963J0DERFxenVatWlVqelJSkbt26OW8nJydr+fLlztsxMTGaMmXKNT02VwQHAMBN9ejRQ88++6wuX76sHTt2aN68eWrUqJFGjRpV6r6XL1+Wl5dXjTyu3W6vke3Up9r4GYgmAADclLe3t/ODhgcPHqz09HR99NFHGjVqlJKSknTu3Dl16tRJb731lry9vbVhwwZ99913Sk5O1s6dO+Xh4aFu3brp6aefVps2bSRJRUVFeuWVV/Tee+/J09NTcXFxpR53/PjxuvXWW/X0009Lki5duqQlS5Zo06ZNOn36tFq1aqWEhAR1797dOSPVu3dvSdKAAQOUlJSk4uJipaSkaP369Tp16pTCwsI0ZswY9enTx/k4O3bs0IIFC3Ts2DFFRkZqwIABNfbcJSQk6MyZM1q/fr0SEhK0detWbd26VcnJyZKkQ4cOqV27dlXaJtEEAEAlPPLz1WrVKgWtWyevkyd1uWVLnYiP17HHHqvTD+z18fFRXl6e8/ann34qf39/LVq0SJJUWFioSZMmqUuXLlq6dKk8PT31+9//XpMmTdLq1avl5eWllStXauPGjZoxY4bCw8O1cuVKpaen66677ir3cWfOnKk9e/YoMTFRHTp00NGjR3XmzBm1atVKc+fO1S9/+Uu9/fbb8vf3V+PGjSVJy5cvV1pamqZPn67Q0FDt3r1bzz77rAIDAxUVFaXvvvtO06ZN0+DBgxUfH699+/Zp4cKFtfK8JScn68CBA4qMjNSsWbMkSUFBQVXeDtEEAEAFPPLz1XH8ePkdOCBbcbEkyfv4cbVZulSBW7fqyyVLaj2cLMvSP//5T+3cuVNDhgxxLm/cuLGeeeYZ5265999/X8XFxXrmmWdks9kkXQmeXr16KSMjQ/fcc49Wr16thIQE58zQ9OnT9Y9//KPcx/7666+1ZcsWLVq0SHfffbck6eabb3aud+wGa968uZo0aSLpyszUsmXL9Nprr6lr167O7/niiy+0bt06RUVF6Z133tFNN92kqVOnSpLatWunr776SitWrKj0+Vi0aJEWL17svO3h4aFLly6pU6dOZd7fbrfL29tbfn5+CgkJqXT75SGaAACoQKtVq1yCycFWXCy/AwfUatUqffvEE7Xy2Nu3b9d9992nwsJCFRcX68EHH9S4ceOc69u3b+9yHFNWVpaOHDmi6Ohol+1cunRJR44c0blz53Ty5El17tzZua5Ro0bq1KmTLMsqcwwHDhyQp6enoqKijMedm5urCxcuaOLEiS7LL1++rI4dO0qSDh8+rMjISJf1jsCqzIgRIzRw4EDn7S5duuiVV17Rtm3bjMdYHUQTAAAVCFq3rlQwORUXK2jdulqLpqioKE2fPl1eXl5q2bKlGjVy/bXt6+vrcrugoEC33XabZs+eXWpbzZo1q9YYfHx8qvw9BQUFkqSXX35ZwcHBLutq4mB1u92u0NBQ5+327durefPm17zdyhBNAABUwOvkyXLX2SpZf618fX1d4qAyHTt21ObNm9WsWTMFBASUeZ+WLVtq7969uvPOOyVdOQ5q3759uu2228q8f/v27VVcXKyMjAzn7rmSHCFXVFTkXBYeHi5vb28dO3as3Bmqdu3alZoZ2rNnT+U/ZDV5e3u7jLE6uE4TAKBaLMuq16+6cvmHs9fKfA4qWV/XYmNjFRgYqMTERO3evVvffPONMjIyNH/+fB07dkySNHToUKWkpCg9PV2HDx/W3Llzde7cuXK32aZNGw0YMECzZ89Wenq6c5ubN2+WJLVu3Vo2m03bt2/X6dOnlZ+fL39/fw0fPlwLFizQxo0bdeTIEe3fv19r167Vxo0bJUkPP/ywcnNzlZycrMOHD2vTpk3OdbWhXbt2+uSTT3T48GGdPHlSxeXNHlaAaAIAoAIn4uNleZTz69LDQyfi4+t2QBVo3LixlixZopCQEE2bNk1DhgzR7NmzdfHiRfn7+0uShg0bptjYWCUlJWn06NHy8/NTTExMhdudPn26+vTpo7lz5+qRRx7RCy+84NwFFxwcrHHjxmnRokXq16+f5s2bJ0maMGGCxowZo+XLl+uRRx7RpEmTtH37duelD0JCQjR37lxt3bpVw4YN07vvvquf//zntfbcJCYmytPTU506dVJQUJBycnKqvA2bZZjrjqPwAUBSnf5L/2q8H7mH+nwNSOavg7Zt22rx4sXO6x1VVcmz51RcLJuuzDDJw0P5t95aJ2fPoWIVXS6hqi5cuKBDhw4pPDzcefkEB2aaAACoQLGfn75cskRHx47V5eBgWR4euhwcrKNjxxJMNxgOBAcAoBLFfn769oknau0sOTQMzDQBAAAYIJoAAAAMEE0AAAAGiCYAwHWtrq/rhIatotcK0QQAuK6dOnVKly5dqu9hoIHIz8+XVPbHvXD2HADgunb+/Hm99957evTRRxUYGFjfw0EtuHDhwjVvw7Is5efn6/jx4woMDJSnp2ep+xBNAIA6kZaVpsjgSIXaS3+WWm5erjKPZyq2Q2ytPPayZcskSXFxcfL29uYCqdeZQ4cO1di2AgMDFRISUuY6rggOoFq4Ijiq8hpIy0pT3Jo4hdnDlD4y3SWccvNyFZMSo5y8HL039D3jcKrO68DPz08tW7bkNXSd2b9/f41sx8vLq8wZJgdmmgAAtS4yOFJh9jBln85WTEqMM5wcwZR9OlsRzSIUGRxZq+PIz8+v1meOwb1d/XEntYWZJgDVwkwTqvoauDqQUuNTNWLdCOftq2egKsPrAA519X5ENAGoFqIJ1XkNlAwnh+oEk8TrAP9VV+9HXHIAAFBnQu2hSo1PdVmWGp9a5WAC6gPRBACoM7l5uRqxboTLshHrRig3L7eeRgSYI5oAAHXi6mOadozeoYhmEc6DwwknuDuiCQBQ664OpvSR6eoZ2lPpI9MJJzQYRBMAoNZlHs9UTl5OqYO+Q+2hznDKyctR5vHMeh4pUD7OngNQLZw9h6q+Bmr6iuC8DuDAJQcAuDWiCfX5GpB4HeC/uOQAAACAGyGaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYaFTfAwAANExckRs3GmaaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQDqjb+kZyTlSCr84b/P/LAccDc2y7IsozvabLU9FgANiOFbR63g/ej64C8pXdKPJHmWWF4kabekGEnn63xUaIjq6v2ImSYAQL2YqtLBpB9u/+iH9YA7YaYJQLUw04RrlSMptJx1lqQjksLqbjhowJhpAgC4vWs5JqlNBetslawH6gMzTQCqhZkmXOsxScw0oaYw0wQAcGvXekzSG7oSWGUp/mE94E6YaQJQLcw04VpnikrOVHnoyi45S1eCibPnUBXMNAEA3Nq1HpN0XlfCKElXAqvoh/8miWCCe2KmqYGpz3/dS7wO8F/MNIFjkuAumGkCALg1jknCjYaZpgaGmSa4C2aawDFJcBfMNAEA3BrHJOFGw0xTA8NME9wFM00A3AUzTQAAAG6EaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANE03UuLStNuXm5Za7LzctVWlZaHY8IAICGiWi6jqVlpSluTZxiUmJKhVNuXq5iUmIUtyaOcAIAwADRdB2LDI5UmD1M2aezXcLJEUzZp7MVZg9TZHBkvY4TAICGgCuCNzBVveppyUCKaBah1PhUjVg3wnk7fWS6Qu3lfU55abwO4MAVwQG4i7p6PyKaGpjqvDBKhpNDdYJJ4nWA/yKaALgLPkYFNSbUHqrU+FSXZanxqVUOJgAAbmRE0w0gNy9XI9aNcFk2Yt2Ics+qAwAApRFN17mrj2naMXqHIppFlDo4HAAAVIxouo5dHUzpI9PVM7Sn0kemE04AAFQR0XQdyzyeqZy8nFIHfYfaQ53hlJOXo8zjmfU8UgAA3B9nzzUwVT1DIC0rTZHBkWUe9J2bl6vM45mK7RBrvD1eB3Dg7DkA7oJLDqBM9fmLSuJ1gP8imgC4Cy45AAAA4EaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABhrV9wBQNVwJGYC74BMKcKNhpgkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQDqRFpWmnLzcstcl5uXq7SstDoeEVA1RBMAoNalZaUpbk2cYlJiSoVTbl6uYlJiFLcmjnCCWyOaAAC1LjI4UmH2MGWfznYJJ0cwZZ/OVpg9TJHBkfU6TqAiNsuyLKM72my1PRYADYjhW0et4P3IPVT1NVAykCKaRSg1PlUj1o1w3k4fma5Qe6jx9ngdwKGu3o+IJgDVQjShOq+BkuHkUJ1gkngd4L/q6v2I3XMAgDoTag9Vanyqy7LU+NQqBxNQH4gmAECdyc3L1Yh1I1yWjVg3otyz6gB3QjQBAOrE1cc07Ri9QxHNIkodHA64K6IJAFDrrg6m9JHp6hnaU+kj0wknNBhEEwCg1mUez1ROXk6pg75D7aHOcMrJy1Hm8cx6HilQPs6eA1AtnD2Hqr4G0rLSFBkcWeZB37l5uco8nqnYDrHG2+N1AAcuOQDArRFNqM/XgMTrAP/FJQcAAADcCNEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0YQa5S/pGUk5kgp/+O8zPywHcH2x2Wz1+gXUNT5GBTXGX1K6pB9J8iyxvEjSbkkxks7X+ahQW/gYFQDugo9RQYMzVaWDST/c/tEP6wEAaKiYaUKNyZFU+rPLr7AkHZEUVnfDQS1jpgmAu6ir9yOiCTWmUKVnmUoqktSojsaC2kc0AXAX7J5Dg3O0gnVWJesBAHB3RBNqzBu6MptUluIf1gMA0FCxew41puTZcx6SbLoyw1Qszp67HrF7DoC7YPccGpzzuhJGSbpy0HfRD/9NEsEEAGj4mGkCUC3MNAFwF8w0AQAAuBGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0w5i/pGUk5kgp/+O8zPywHAOB6Z7MsyzK6o81W22OBG/OXlC7pR5I8SywvkrRbUoyk83U+KtQnw7eOWsH7EYCS6ur9iJkmGJmq0sGkH27/6If1AABcz5hpgpEcSaHlrLMkHZEUVnfDgRtgpgmAu6ir9yOiCUYKVXqWqaQiSY3qaCxwD0QTAHfB7jm4laMVrLMqWQ8AwPWAaIKRN3RlNqksxT+sBwDgesbuORgpefachySbrswwFYuz525U7J4D4C7YPQe3cl5XwihJVw76Lvrhv0kimAAANwZmmgBUCzNNANwFM00AAABuhGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAICBRvU9ADQslmXV9xBks9nqewgAgBsQM00AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCbUuLStNuXm5Za7LzctVWlZaHY8IAICqI5pQq9Ky0hS3Jk4xKTGlwik3L1cxKTGKWxNHOAEA3B7RhFoVGRypMHuYsk9nu4STI5iyT2crzB6myODIeh0nAACVsVmWZRnd0War7bGgATB8ubgoGUgRzSKUGp+qEetGOG+nj0xXqD3UeHu8Ft1DdV4LNYXXAICS6ur9iGhClVT3hVkynByqE0wSr0V3QTQBcBd19X7E7jnUiVB7qFLjU12WpcanVjmYAACoL0QT6kRuXq5GrBvhsmzEuhHlnlUHAIC7IZpQ664+pmnH6B2KaBZR6uBwAADcGdGEWnV1MKWPTFfP0J5KH5lOOAEAGhSiCbUq83imcvJySh30HWoPdYZTTl6OMo9n1vNIAQCoGGfPoUqqc4ZCWlaaIoMjyzzoOzcvV5nHMxXbIdZ4e7wW3QNnzwFwF1xyAG6pPn9ROvBadA9EEwB3wSUHAAAA3AjRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAgPEVwQEAAG5kzDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwEAj0zvabLbaHAeABsayrHp7bN6PAJRUV+9HzDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMNCovgcAoOosy6rvIQDADYeZJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEE3CDSstKUm5db5rrcvFylZaXV8YgAoGEhmoAbQFpWmuLWxCkmJaZUOOXm5SomJUZxa+IIJwCoANEEXI/OnZNmz5ZCQyVPT/WNGa15O5vo2HfZLuHkCKbs09kKs4cpMjiyXocNAO7MZlmWZXRHm622xwLAUIV/bc+dk6Kjpc8/l4qL//s9Hh7KbNNIPUZcUquQCKXGp2rEuhHKPp2tiGYRSh+ZrlB7aO0PvgbwfgSgJMOUuWZEE9AAVfjXdvZsKSnJJZic3+fhoYUP2vWLH592LmtowSTxfgTAFdEEoFwV/rUNDZWOHCl39cWQIDWecMJ5e8foHeoZ2rMmh1freD8CUFJdRRPHNAHXm6NHK1zd6NgJl9sj1o0o96w6AMB/EU3A9aZNm3JXWZKONrmyS27H6B2KaBah7NPZZZ5VBwBwRTQB15tx4ySPsv9qF9ukt3/STOkj09UztKfSR6YTTgBgiGgCrjdTp0rdurmEkyWpyCb9+yZvPfLGx86DvkPtoc5wysnLUebxzPoZMwA0ABwIDjRAlf61PXdOevll6Y03rhzj1KaNDjwcI7//92vdfNNtpe6em5erzOOZiu0QW0sjrlm8HwEoibPnAJSrrt4g3BXvRwBK4uw5AAAAN0I0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAw0Ki+BwCg6tzhitg3+lXJAdx4mGkCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGLBZlmXV9yAAAADcHTNNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAG/j86+gpVQHxqNgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example usage\n", + "visualize_predictions_with_original(model, val_dataset_flat, tile_size=8, max_hits_per_tile=5, num_images=2, threshold=0.1)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Electron Counting Tiling approach/256 by 256 images 1.ipynb b/Electron Counting Tiling approach/256 by 256 images 1.ipynb new file mode 100644 index 0000000..e9a127f --- /dev/null +++ b/Electron Counting Tiling approach/256 by 256 images 1.ipynb @@ -0,0 +1,5443 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 17:59:34.452398: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-25 17:59:34.466135: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-25 17:59:34.479344: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-25 17:59:34.483282: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-25 17:59:34.494663: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-25 17:59:35.118403: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 17:59:36.558379: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-25 17:59:36.559829: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79196 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1]\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + "\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " # Reshape images\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and flatten them\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile, 2)\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " # Normalize data\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten tiles for individual input to the model\n", + " train_images_flat = train_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + " val_images_flat = val_images.reshape(-1, 8, 8, 1) # Shape: (num_tiles, 8, 8, 1)\n", + "\n", + " # Flatten centers to match tiles\n", + " train_centers_flat = train_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + " val_centers_flat = val_centers.reshape(-1, 2, 2) # Shape: (num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # Create TensorFlow datasets\n", + " batch_size = 2000 \n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "def calculate_precision_recall(predicted_centers, true_centers, tile_size, threshold=0.1):\n", + " TP, FP, FN = 0, 0, 0\n", + "\n", + " for tile_idx in range(len(predicted_centers)):\n", + " predicted_hits = predicted_centers[tile_idx]\n", + " true_hits = true_centers[tile_idx]\n", + "\n", + " # Filter valid predicted hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in predicted_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + "\n", + " # Filter valid true hits\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0]) ** 2 + (pred[1] - true_hit[1]) ** 2)\n", + " if distance <= threshold * tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + " precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + " recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + " return precision, recall\n", + "\n", + "# File path and data loading\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_200_256by256_95indexNoNoise.h5'###### used this for my work on November 23\n", + "# file_path ='/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_100_256by256_Randomindex.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "images, centers = data_loader.load_data()\n", + "# Create datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " \"\"\"\n", + " Create a model that predicts hit locations for individual tiles.\n", + " \n", + " Parameters:\n", + " - input_shape: shape of the input tile (e.g., (8, 8, 1)).\n", + " - max_hits: maximum number of hits per tile (e.g., 2).\n", + "\n", + " Returns:\n", + " - model: The Keras model.\n", + " \"\"\"\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + "\n", + " # Convolutional and pooling layers\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " x = layers.Flatten()(x)\n", + "\n", + " # Dense layers\n", + " x = layers.Dense(128, activation='relu')(x)\n", + "\n", + " # Final dense layer for predictions\n", + " outputs = layers.Dense(max_hits * 2,activation='sigmoid')(x)\n", + "\n", + " # Reshape output to match the target structure per tile\n", + " outputs = layers.Reshape((max_hits, 2))(outputs)\n", + "\n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((8000, 1024, 8, 8),\n", + " (2000, 1024, 8, 8),\n", + " (8000, 1024, 2, 2),\n", + " (2000, 1024, 2, 2))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 4)              │           516 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ reshape (Reshape)               │ (None, 2, 2)           │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Train the model\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6)\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model = create_model()\n", + " model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='mse')\n", + " model.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:01:44.316831: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "2024-11-25 18:01:46.395384: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-25 18:01:46.405100: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1732575706.500433 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.504497 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.539082 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.539250 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.539537 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.539763 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.544814 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.545035 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.560649 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.560756 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.562652 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.562779 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.563314 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.563551 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.563763 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.564005 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.565495 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.565698 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.581285 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.581539 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.581709 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.581944 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582109 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582338 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582505 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582718 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.582904 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.583126 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.583295 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.583510 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.584932 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.585141 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.586650 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.586768 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.588225 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.588437 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.589953 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.590159 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.591513 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.591746 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.593408 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.593630 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.593825 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.594044 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.595212 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.595326 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.602111 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.602218 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.603722 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.603930 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.679836 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.680175 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.680418 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.680773 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.681428 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.681465 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682075 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682275 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682453 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682611 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.682927 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683100 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683403 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683479 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683726 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.683973 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.684265 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.684336 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.684537 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.684776 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685210 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685423 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685523 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685892 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.685979 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.686154 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.686554 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.687149 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.687453 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.687638 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.687818 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.688000 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.688182 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.688338 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.689515 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.689592 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.689927 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690006 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690347 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690362 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690731 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.690812 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.691976 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.692054 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.692354 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.692453 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.698635 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.698708 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699016 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699118 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699355 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699526 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699729 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.699882 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.700218 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.700385 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.700721 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.700966 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.703227 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.703466 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.704340 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.704574 3544336 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 9/4096\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m27s\u001b[0m 7ms/step - loss: 0.2304 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1732575706.970318 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.970318 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.971715 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.971721 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.973640 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.973710 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974025 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974099 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974386 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974460 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974847 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.974967 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.975342 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.975348 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.975659 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.975666 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.977905 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.977979 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.978285 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.978364 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.980439 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.980515 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982186 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982281 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982468 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982585 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982765 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.982939 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983107 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983289 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983466 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983667 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.983872 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.984054 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.984232 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.984391 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.985667 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.985758 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.987169 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.987264 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.987471 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.987626 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.993381 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.993457 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.993770 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.993874 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.994181 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.994332 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.994972 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.995118 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.996477 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575706.996570 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.013415 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.013420 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.016009 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.016084 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.030204 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.030232 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.031509 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.031601 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.032061 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.032154 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.032683 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.032678 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.033835 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.033908 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.035340 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.035433 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.036062 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.036137 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.036442 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.036517 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.037079 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.037151 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.037707 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.037801 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.039285 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.039292 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.039736 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.039811 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.040110 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.040186 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.041663 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.041748 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.043108 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.043183 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.045014 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.045106 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.046683 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.046764 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.047550 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.047637 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.048584 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.048659 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.061140 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.061147 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.061679 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.061686 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.062108 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.062114 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063089 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063164 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063502 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063578 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.063933 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064011 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064365 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064440 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064799 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.064884 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.065166 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.065258 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.065555 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.065644 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.066248 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.066344 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.070857 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.070950 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.071312 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.071320 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.072318 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.072395 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.072847 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.072923 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.073615 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.073688 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.073945 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.074102 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.076598 3544327 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575707.076763 3544331 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 0.0100" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:02:16.266917: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:02:16.267069: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:02:16.779043: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "W0000 00:00:1732575736.977608 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.977645 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.978448 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.978534 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.978994 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.979076 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.979517 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.979600 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.980030 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.980110 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.980539 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.980621 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.981049 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.981128 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.981567 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.981658 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.982074 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.982152 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.986551 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.986637 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.987080 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.987176 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.987601 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.987686 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.988084 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.988181 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.988483 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.988846 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.989230 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.989468 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.989690 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990004 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990282 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990468 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990738 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.990960 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.991190 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.991427 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.991661 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.991970 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.992253 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.992427 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.995736 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.995808 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.996427 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.996498 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.996943 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.997027 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.997459 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.997537 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.998088 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.998172 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.998663 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.998726 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.999174 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.999260 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.999690 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575736.999790 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.000226 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.000321 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.000807 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.000881 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.001422 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.001509 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.001943 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.002025 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.002468 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.002533 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.003054 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.003138 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.003710 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.003792 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.004259 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.004342 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.005573 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.005709 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.006217 3544325 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732575737.006402 3544324 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 8ms/step - loss: 0.0100 - val_loss: 7.1061e-04 - learning_rate: 0.0010\n", + "Epoch 2/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:02:19.993148: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.1475e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:02:49.555426: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:02:49.688778: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 7.1475e-04 - val_loss: 7.0710e-04 - learning_rate: 0.0010\n", + "Epoch 3/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0729e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:03:23.310957: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0729e-04 - val_loss: 7.0463e-04 - learning_rate: 0.0010\n", + "Epoch 4/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:03:25.995820: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0442e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:03:56.968466: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0441e-04 - val_loss: 7.0421e-04 - learning_rate: 0.0010\n", + "Epoch 5/50\n", + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0309e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:04:30.703699: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0309e-04 - val_loss: 7.0269e-04 - learning_rate: 0.0010\n", + "Epoch 6/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0178e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:05:04.209486: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:05:04.318436: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0178e-04 - val_loss: 7.0256e-04 - learning_rate: 0.0010\n", + "Epoch 7/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0107e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:05:37.832506: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 7.0107e-04 - val_loss: 7.0290e-04 - learning_rate: 0.0010\n", + "Epoch 8/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.0049e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:06:11.112323: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 7.0049e-04 - val_loss: 7.0294e-04 - learning_rate: 0.0010\n", + "Epoch 9/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 6ms/step - loss: 6.9983e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:06:42.071696: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 7ms/step - loss: 6.9983e-04 - val_loss: 7.0283e-04 - learning_rate: 0.0010\n", + "Epoch 10/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9926e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:07:14.635532: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 6.9926e-04 - val_loss: 7.0286e-04 - learning_rate: 0.0010\n", + "Epoch 11/50\n", + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9897e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:07:48.329451: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 11: ReduceLROnPlateau reducing learning rate to 0.0009000000427477062.\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9897e-04 - val_loss: 7.0244e-04 - learning_rate: 0.0010\n", + "Epoch 12/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:07:50.989971: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9825e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:08:20.942430: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9825e-04 - val_loss: 7.0195e-04 - learning_rate: 9.0000e-04\n", + "Epoch 13/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9787e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:08:55.157072: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9787e-04 - val_loss: 7.0162e-04 - learning_rate: 9.0000e-04\n", + "Epoch 14/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9757e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:09:28.011379: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9757e-04 - val_loss: 7.0169e-04 - learning_rate: 9.0000e-04\n", + "Epoch 15/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9739e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:10:01.753473: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9739e-04 - val_loss: 7.0184e-04 - learning_rate: 9.0000e-04\n", + "Epoch 16/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9695e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:10:35.887172: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9695e-04 - val_loss: 7.0223e-04 - learning_rate: 9.0000e-04\n", + "Epoch 17/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9672e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:11:08.453187: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 6.9672e-04 - val_loss: 7.0253e-04 - learning_rate: 9.0000e-04\n", + "Epoch 18/50\n", + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9663e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:11:42.664170: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9663e-04 - val_loss: 7.0300e-04 - learning_rate: 9.0000e-04\n", + "Epoch 19/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9639e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:12:15.652715: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9639e-04 - val_loss: 7.0343e-04 - learning_rate: 9.0000e-04\n", + "Epoch 20/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9622e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:12:49.302067: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9622e-04 - val_loss: 7.0398e-04 - learning_rate: 9.0000e-04\n", + "Epoch 21/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9604e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:13:22.237067: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 21: ReduceLROnPlateau reducing learning rate to 0.0008100000384729356.\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9604e-04 - val_loss: 7.0414e-04 - learning_rate: 9.0000e-04\n", + "Epoch 22/50\n", + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9506e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:13:55.626178: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-25 18:13:56.072721: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9506e-04 - val_loss: 7.0493e-04 - learning_rate: 8.1000e-04\n", + "Epoch 23/50\n", + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9467e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:14:30.001112: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9467e-04 - val_loss: 7.0526e-04 - learning_rate: 8.1000e-04\n", + "Epoch 24/50\n", + "\u001b[1m4089/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9462e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:15:03.320805: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9462e-04 - val_loss: 7.0547e-04 - learning_rate: 8.1000e-04\n", + "Epoch 25/50\n", + "\u001b[1m4094/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9412e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:15:36.483315: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9412e-04 - val_loss: 7.0571e-04 - learning_rate: 8.1000e-04\n", + "Epoch 26/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9377e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:16:10.544894: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9377e-04 - val_loss: 7.0559e-04 - learning_rate: 8.1000e-04\n", + "Epoch 27/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9319e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:16:43.530632: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9319e-04 - val_loss: 7.0660e-04 - learning_rate: 8.1000e-04\n", + "Epoch 28/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9307e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:17:17.351245: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9307e-04 - val_loss: 7.0645e-04 - learning_rate: 8.1000e-04\n", + "Epoch 29/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9262e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:17:50.209043: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9262e-04 - val_loss: 7.0717e-04 - learning_rate: 8.1000e-04\n", + "Epoch 30/50\n", + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9186e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:18:24.009464: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.9186e-04 - val_loss: 7.0898e-04 - learning_rate: 8.1000e-04\n", + "Epoch 31/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9135e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:18:57.247716: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 31: ReduceLROnPlateau reducing learning rate to 0.0007290000503417104.\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9135e-04 - val_loss: 7.0974e-04 - learning_rate: 8.1000e-04\n", + "Epoch 32/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.9043e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:19:29.954048: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.9043e-04 - val_loss: 7.1013e-04 - learning_rate: 7.2900e-04\n", + "Epoch 33/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8989e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:20:04.154027: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8989e-04 - val_loss: 7.1156e-04 - learning_rate: 7.2900e-04\n", + "Epoch 34/50\n", + "\u001b[1m4089/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8950e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:20:36.273825: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 6.8950e-04 - val_loss: 7.1195e-04 - learning_rate: 7.2900e-04\n", + "Epoch 35/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8877e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:21:10.495541: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8877e-04 - val_loss: 7.1192e-04 - learning_rate: 7.2900e-04\n", + "Epoch 36/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8820e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:21:43.211982: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8820e-04 - val_loss: 7.1346e-04 - learning_rate: 7.2900e-04\n", + "Epoch 37/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8738e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:22:16.765805: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8738e-04 - val_loss: 7.1422e-04 - learning_rate: 7.2900e-04\n", + "Epoch 38/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8696e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:22:50.600841: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8696e-04 - val_loss: 7.1470e-04 - learning_rate: 7.2900e-04\n", + "Epoch 39/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8657e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:23:23.569169: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8657e-04 - val_loss: 7.1626e-04 - learning_rate: 7.2900e-04\n", + "Epoch 40/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8558e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:23:57.777212: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8558e-04 - val_loss: 7.1619e-04 - learning_rate: 7.2900e-04\n", + "Epoch 41/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8516e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:24:30.619844: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 41: ReduceLROnPlateau reducing learning rate to 0.0006561000715009868.\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8516e-04 - val_loss: 7.1829e-04 - learning_rate: 7.2900e-04\n", + "Epoch 42/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8387e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:25:04.575765: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8387e-04 - val_loss: 7.1641e-04 - learning_rate: 6.5610e-04\n", + "Epoch 43/50\n", + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8286e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:25:38.073704: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8286e-04 - val_loss: 7.1630e-04 - learning_rate: 6.5610e-04\n", + "Epoch 44/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:25:40.797286: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4095/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8219e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:26:11.445883: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8219e-04 - val_loss: 7.1707e-04 - learning_rate: 6.5610e-04\n", + "Epoch 45/50\n", + "\u001b[1m4090/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8170e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:26:45.459640: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8170e-04 - val_loss: 7.1744e-04 - learning_rate: 6.5610e-04\n", + "Epoch 46/50\n", + "\u001b[1m4093/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8099e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:27:18.204160: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.8099e-04 - val_loss: 7.1814e-04 - learning_rate: 6.5610e-04\n", + "Epoch 47/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.8052e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:27:52.023395: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.8051e-04 - val_loss: 7.1991e-04 - learning_rate: 6.5610e-04\n", + "Epoch 48/50\n", + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.7953e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:28:23.747132: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 8ms/step - loss: 6.7953e-04 - val_loss: 7.1891e-04 - learning_rate: 6.5610e-04\n", + "Epoch 49/50\n", + "\u001b[1m4091/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.7944e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:28:57.858164: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 8ms/step - loss: 6.7943e-04 - val_loss: 7.1873e-04 - learning_rate: 6.5610e-04\n", + "Epoch 50/50\n", + "\u001b[1m4092/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 6.7861e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 18:29:30.433637: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m4096/4096\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 8ms/step - loss: 6.7861e-04 - val_loss: 7.2237e-04 - learning_rate: 6.5610e-04\n" + ] + } + ], + "source": [ + "\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=50,\n", + " batch_size=1000,\n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "model.save('/home/da886/Electron Counting Tiling approach/Trained weights/10KFixed_200_256by256_95indexNoNoise_sigmoid_mse.keras')\n", + "# loaded_model = tf.keras.models.load_model('/home/da886/Electron Counting Tiling approach/Trained weights/200KFixed_100_256by256_first1500_mse and sigmoid_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 49/3840\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m3s\u001b[0m 1ms/step " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-02 11:14:20.563261: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "W0000 00:00:1733156060.667207 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.667285 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.668098 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.668122 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.668638 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.668663 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.669093 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.669166 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.669545 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.669619 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670016 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670089 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670525 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670643 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.670872 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671102 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671230 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671509 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671667 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.671902 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672075 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672311 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672491 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672760 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.672910 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.673199 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.673352 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.673608 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.673756 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674037 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674181 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674470 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674617 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.674847 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675055 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675222 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675455 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675621 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.675898 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676049 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676315 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676479 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676764 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.676908 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.677204 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.677329 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.677616 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.677766 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.678428 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.678512 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.678897 3544283 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1733156060.678982 3544268 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m3840/3840\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 956us/step\n", + "Predicted centers shape: (120, 1024, 2, 2)\n", + "Grouped targets shape: (120, 1024, 2, 2)\n" + ] + } + ], + "source": [ + "# # Flatten validation images and centers\n", + "val_images_flat = val_images.reshape(-1, 8, 8, 1)\n", + "val_centers_flat = val_centers.reshape(-1, 2, 2)\n", + "\n", + "# train_images_flat = train_images.reshape(-1, 8, 8, 1)\n", + "# train_centers_flat = train_centers.reshape(-1, 2, 2)\n", + "\n", + "# Batch size for 8 images\n", + "batch_size = 120 * 1024 # 8 images per batch\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "# train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "# Make predictions on the validation dataset\n", + "inputs, targets = next(iter(val_dataset)) # Extract a batch\n", + "outputs = model.predict(inputs)\n", + "\n", + "# Reshape predictions and targets back to image structure\n", + "predicted_centers = outputs.reshape(-1, 1024, 2, 2)\n", + "grouped_targets = targets.numpy().reshape(-1, 1024, 2, 2)\n", + "\n", + "# Print the shapes\n", + "print(f\"Predicted centers shape: {predicted_centers.shape}\") # (batch_size // 1024, 1024, 2, 2)\n", + "print(f\"Grouped targets shape: {grouped_targets.shape}\") # (batch_size // 1024, 1024, 2, 2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions for image index 12:\n", + "Tile 0: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 2: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 3: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 4: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 5: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 6: Predicted: [[2.5060314e-01 6.2125230e-01]\n", + " [1.6710628e-08 8.0681538e-08]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 7: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 8: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 9: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 10: Predicted: [[8.7523717e-01 3.8167289e-01]\n", + " [3.9516075e-07 7.6895866e-08]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 11: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 12: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 13: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 14: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 15: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 16: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 17: Predicted: [[8.79141867e-01 7.49784112e-01]\n", + " [4.87319925e-17 1.29109196e-17]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 18: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 19: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 20: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 21: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 22: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 23: Predicted: [[2.4865903e-01 6.2434858e-01]\n", + " [3.8695064e-14 8.5702333e-14]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 24: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 25: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 26: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 27: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 28: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 29: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 30: Predicted: [[6.3254559e-01 1.2587267e-01]\n", + " [1.3719537e-09 1.0555828e-10]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 31: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 32: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 33: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 34: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 35: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 36: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 37: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 38: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 39: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 40: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 41: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 42: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 43: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 44: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 45: Predicted: [[2.5048652e-01 4.9581537e-01]\n", + " [2.2247423e-06 5.4696679e-06]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 46: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 47: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 48: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 49: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 50: Predicted: [[2.8206867e-05 3.8382447e-01]\n", + " [5.7517273e-15 5.5375822e-14]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 51: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 52: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 53: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 54: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 55: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 56: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 57: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 58: Predicted: [[5.0116467e-01 8.7715721e-01]\n", + " [2.1562087e-17 2.3313819e-17]], True: [[0.5 0.875]\n", + " [0. 0. ]]\n", + "Tile 59: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 60: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 61: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 62: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 63: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 64: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 65: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 66: Predicted: [[8.7217993e-01 2.4894524e-01]\n", + " [2.8863778e-07 3.1922930e-08]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 67: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 68: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 69: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 70: Predicted: [[3.9728886e-05 8.7667716e-01]\n", + " [2.7492750e-15 6.0215860e-12]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 71: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 72: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 73: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 74: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 75: Predicted: [[3.6967170e-01 3.7001207e-01]\n", + " [3.2294943e-06 3.3352326e-06]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 76: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 77: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 78: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 79: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 80: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 81: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 82: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 83: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 84: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 85: Predicted: [[4.2091551e-06 7.6305664e-01]\n", + " [7.2256634e-21 7.2267182e-19]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 86: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 87: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 88: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 89: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 90: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 91: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 92: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 93: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 94: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 95: Predicted: [[8.73314738e-01 1.21971026e-01]\n", + " [3.17704456e-17 3.39339266e-19]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 96: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 97: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 98: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 99: Predicted: [[3.1420742e-03 4.9609739e-01]\n", + " [9.2912569e-07 5.9589478e-05]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 100: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 101: Predicted: [[6.2480927e-01 9.0272218e-04]\n", + " [5.4396503e-07 8.2624902e-09]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 102: Predicted: [[5.0110841e-01 7.5182831e-01]\n", + " [5.4996099e-07 2.1232045e-06]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 103: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 104: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 105: Predicted: [[8.7087965e-01 6.2128061e-01]\n", + " [5.2493997e-06 1.6517998e-06]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 106: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 107: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 108: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 109: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 110: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 111: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 112: Predicted: [[6.2876254e-01 3.7659714e-01]\n", + " [1.1955622e-13 2.8288109e-14]], True: [[0.625 0.375]\n", + " [0. 0. ]]\n", + "Tile 113: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 114: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 115: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 116: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 117: Predicted: [[6.2850374e-01 4.9779031e-01]\n", + " [2.1727372e-11 1.0517137e-11]], True: [[0.625 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 118: Predicted: [[8.8086069e-01 6.2502652e-01]\n", + " [2.9353957e-17 3.9358962e-18]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 119: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 120: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 121: Predicted: [[7.5147665e-01 6.1706422e-05]\n", + " [9.9940991e-14 4.6818108e-17]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 122: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 123: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 124: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 125: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 126: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 127: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 128: Predicted: [[8.7039524e-01 4.9657050e-01]\n", + " [5.4976622e-06 1.2262326e-06]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 129: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 130: Predicted: [[5.01869828e-04 6.03021879e-04]\n", + " [2.13671442e-12 1.39067915e-11]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 131: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 132: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 133: Predicted: [[0.4580677 0.65326804]\n", + " [0.4574413 0.58535695]], True: [[0. 0.875]\n", + " [0.875 0.375]]\n", + "Tile 134: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 135: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 136: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 137: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 138: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 139: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 140: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 141: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 142: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 143: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 144: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 145: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 146: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 147: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 148: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 149: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 150: Predicted: [[2.4846141e-01 8.7407380e-01]\n", + " [6.3684430e-14 3.9657999e-13]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 151: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 152: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 153: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 154: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 155: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 156: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 157: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 158: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 159: Predicted: [[4.9824399e-01 7.5110126e-01]\n", + " [3.2777641e-13 6.7520642e-13]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 160: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 161: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 162: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 163: Predicted: [[5.4404006e-04 3.7546444e-01]\n", + " [1.2051814e-08 6.4150203e-07]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 164: Predicted: [[0.63989687 0.5194765 ]\n", + " [0.6220644 0.47348565]], True: [[0.5 0.625]\n", + " [0.75 0.375]]\n", + "Tile 165: Predicted: [[7.5021034e-01 3.7299672e-01]\n", + " [2.5723321e-06 5.7520435e-07]], True: [[0.75 0.375]\n", + " [0. 0. ]]\n", + "Tile 166: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 167: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 168: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 169: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 170: Predicted: [[3.6954030e-01 1.2560870e-01]\n", + " [6.4141426e-04 1.6775219e-04]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 171: Predicted: [[6.2435466e-01 6.2251163e-01]\n", + " [7.2534680e-11 8.2606373e-11]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 172: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 173: Predicted: [[3.30794719e-05 1.24858186e-01]\n", + " [1.32604305e-16 2.09689062e-15]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 174: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 175: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 176: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 177: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 178: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 179: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 180: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 181: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 182: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 183: Predicted: [[1.2929064e-01 8.7743336e-01]\n", + " [8.9530516e-21 1.4826615e-19]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 184: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 185: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 186: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 187: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 188: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 189: Predicted: [[5.0277382e-01 6.2598670e-01]\n", + " [2.4116009e-08 3.2351515e-08]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 190: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 191: Predicted: [[2.4945782e-01 2.5285539e-01]\n", + " [4.0789327e-09 4.8504996e-09]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 192: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 193: Predicted: [[3.30794719e-05 1.24858186e-01]\n", + " [1.32604305e-16 2.09689062e-15]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 194: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 195: Predicted: [[8.7087965e-01 6.2128061e-01]\n", + " [5.2493997e-06 1.6517998e-06]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 196: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 197: Predicted: [[6.2687379e-01 1.2915131e-01]\n", + " [1.2236054e-04 1.2415225e-05]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 198: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 199: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 200: Predicted: [[1.2393859e-01 4.9950731e-01]\n", + " [7.3854807e-07 8.0889831e-06]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 201: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 202: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 203: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 204: Predicted: [[3.7114298e-01 5.0327200e-01]\n", + " [6.4670235e-07 1.0733629e-06]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 205: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 206: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 207: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 208: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 209: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 210: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 211: Predicted: [[4.2091551e-06 7.6305664e-01]\n", + " [7.2256634e-21 7.2267182e-19]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 212: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 213: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 214: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 215: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 216: Predicted: [[3.7056655e-01 7.4863881e-01]\n", + " [1.8702304e-09 4.9766862e-09]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 217: Predicted: [[0.66226506 0.07698739]\n", + " [0.6983214 0.0672325 ]], True: [[0.625 0.125]\n", + " [0.75 0. ]]\n", + "Tile 218: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 219: Predicted: [[2.5215873e-01 7.5172102e-01]\n", + " [8.5552697e-11 3.9774264e-10]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 220: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 221: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 222: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 223: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 224: Predicted: [[2.5089476e-01 8.7780875e-01]\n", + " [2.4941734e-08 3.4284457e-07]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 225: Predicted: [[5.01869828e-04 6.03021879e-04]\n", + " [2.13671442e-12 1.39067915e-11]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 226: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 227: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 228: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 229: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 230: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 231: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 232: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 233: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 234: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 235: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 236: Predicted: [[6.2102526e-01 2.4899058e-01]\n", + " [2.1521066e-04 4.2915959e-05]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 237: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 238: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 239: Predicted: [[0.43526715 0.76473254]\n", + " [0.42426988 0.7469616 ]], True: [[0.375 0.75 ]\n", + " [0.5 0.75 ]]\n", + "Tile 240: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 241: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 242: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 243: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 244: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 245: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 246: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 247: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 248: Predicted: [[2.5215873e-01 7.5172102e-01]\n", + " [8.5552697e-11 3.9774264e-10]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 249: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 250: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 251: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 252: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 253: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 254: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 255: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 256: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 257: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 258: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 259: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 260: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 261: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 262: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 263: Predicted: [[1.2422500e-01 1.2733902e-01]\n", + " [2.0064499e-08 1.8320929e-08]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 264: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 265: Predicted: [[2.4886039e-01 2.5244540e-01]\n", + " [3.3260326e-07 2.6307825e-07]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 266: Predicted: [[3.7823945e-01 8.7176055e-01]\n", + " [3.1127118e-11 2.4505475e-10]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 267: Predicted: [[8.7217993e-01 2.4894524e-01]\n", + " [2.8863778e-07 3.1922930e-08]], True: [[0.875 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 268: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 269: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 270: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 271: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 272: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 273: Predicted: [[8.79141867e-01 7.49784112e-01]\n", + " [4.87319925e-17 1.29109196e-17]], True: [[0.875 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 274: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 275: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 276: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 277: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 278: Predicted: [[3.7822327e-01 2.4915342e-01]\n", + " [6.6363150e-08 3.3251315e-08]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 279: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 280: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 281: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 282: Predicted: [[0.6752565 0.47998843]\n", + " [0.68016636 0.49067408]], True: [[0.875 0.5 ]\n", + " [0.5 0.5 ]]\n", + "Tile 283: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 284: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 285: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 286: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 287: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 288: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 289: Predicted: [[6.2967515e-01 8.6975658e-01]\n", + " [6.1289660e-07 2.0044629e-06]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 290: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 291: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 292: Predicted: [[2.4606220e-01 1.3069469e-01]\n", + " [3.3556193e-05 1.5154692e-05]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 293: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 294: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 295: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 296: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 297: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 298: Predicted: [[7.4926120e-01 7.3678785e-07]\n", + " [6.2000773e-08 3.2475256e-10]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 299: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 300: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 301: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 302: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 303: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 304: Predicted: [[2.8206867e-05 3.8382447e-01]\n", + " [5.7517273e-15 5.5375822e-14]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 305: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 306: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 307: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 308: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 309: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 310: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 311: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 312: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 313: Predicted: [[8.7532055e-01 3.7610188e-01]\n", + " [6.0160536e-19 3.6371070e-20]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 314: Predicted: [[4.99921560e-01 4.97585803e-01]\n", + " [1.14282876e-08 1.01964135e-08]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 315: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 316: Predicted: [[1.1910531e-01 7.5485933e-01]\n", + " [2.0206304e-18 1.7182666e-17]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 317: Predicted: [[7.3645042e-06 6.3326252e-01]\n", + " [1.9430138e-18 4.7767196e-17]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 318: Predicted: [[1.1271351e-06 1.6517430e-05]\n", + " [4.4691638e-20 6.3501384e-22]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 319: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 320: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 321: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 322: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 323: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 324: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 325: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 326: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 327: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 328: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 329: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 330: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 331: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 332: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 333: Predicted: [[4.9776632e-01 1.0373959e-03]\n", + " [3.0877846e-04 6.7208011e-06]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 334: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 335: Predicted: [[0.5825775 0.827289 ]\n", + " [0.45158622 0.79906225]], True: [[0.875 0.75 ]\n", + " [0.125 0.875]]\n", + "Tile 336: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 337: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 338: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 339: Predicted: [[8.73314738e-01 1.21971026e-01]\n", + " [3.17704456e-17 3.39339266e-19]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 340: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 341: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 342: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 343: Predicted: [[5.1031840e-01 6.6823879e-05]\n", + " [1.1857227e-12 2.0964586e-15]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 344: Predicted: [[4.99921560e-01 4.97585803e-01]\n", + " [1.14282876e-08 1.01964135e-08]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 345: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 346: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 347: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 348: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 349: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 350: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 351: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 352: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 353: Predicted: [[3.9728886e-05 8.7667716e-01]\n", + " [2.7492750e-15 6.0215860e-12]], True: [[0. 0.875]\n", + " [0. 0. ]]\n", + "Tile 354: Predicted: [[0.30954725 0.4511352 ]\n", + " [0.30811647 0.5032114 ]], True: [[0.375 0.75 ]\n", + " [0.25 0.25 ]]\n", + "Tile 355: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 356: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 357: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 358: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 359: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 360: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 361: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 362: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 363: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 364: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 365: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 366: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 367: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 368: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 369: Predicted: [[7.5646979e-01 8.7383193e-01]\n", + " [2.4418881e-17 1.5137468e-17]], True: [[0.75 0.875]\n", + " [0. 0. ]]\n", + "Tile 370: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 371: Predicted: [[5.1031840e-01 6.6823879e-05]\n", + " [1.1857227e-12 2.0964586e-15]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 372: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 373: Predicted: [[3.7844190e-01 1.2624583e-01]\n", + " [1.1740613e-08 2.4694908e-09]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 374: Predicted: [[2.4865903e-01 6.2434858e-01]\n", + " [3.8695064e-14 8.5702333e-14]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 375: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 376: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 377: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 378: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 379: Predicted: [[5.0102812e-01 2.5289038e-01]\n", + " [2.1090395e-12 4.9852640e-13]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 380: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 381: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 382: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 383: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 384: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 385: Predicted: [[6.2480927e-01 9.0272218e-04]\n", + " [5.4396503e-07 8.2624902e-09]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 386: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 387: Predicted: [[3.7442595e-01 7.5275952e-01]\n", + " [3.6405586e-06 1.5372232e-05]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 388: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 389: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 390: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 391: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 392: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 393: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 394: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 395: Predicted: [[3.7823945e-01 8.7176055e-01]\n", + " [3.1127118e-11 2.4505475e-10]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 396: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 397: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 398: Predicted: [[8.7400442e-01 1.2699872e-01]\n", + " [8.2201780e-08 5.0394422e-09]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 399: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 400: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 401: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 402: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 403: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 404: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 405: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 406: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 407: Predicted: [[3.6844537e-01 3.7555537e-01]\n", + " [2.1626221e-09 1.8876078e-09]], True: [[0.375 0.375]\n", + " [0. 0. ]]\n", + "Tile 408: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 409: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 410: Predicted: [[2.5215873e-01 7.5172102e-01]\n", + " [8.5552697e-11 3.9774264e-10]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 411: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 412: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 413: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 414: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 415: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 416: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 417: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 418: Predicted: [[7.5369906e-01 4.9389994e-01]\n", + " [8.1189569e-08 2.8317295e-08]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 419: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 420: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 421: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 422: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 423: Predicted: [[1.2686120e-03 6.1855143e-01]\n", + " [2.4361670e-09 4.1626069e-07]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 424: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 425: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 426: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 427: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 428: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 429: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 430: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 431: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 432: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 433: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 434: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 435: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 436: Predicted: [[4.9824399e-01 7.5110126e-01]\n", + " [3.2777641e-13 6.7520642e-13]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 437: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 438: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 439: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 440: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 441: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 442: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 443: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 444: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 445: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 446: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 447: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 448: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 449: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 450: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 451: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 452: Predicted: [[6.2435466e-01 6.2251163e-01]\n", + " [7.2534680e-11 8.2606373e-11]], True: [[0.625 0.625]\n", + " [0. 0. ]]\n", + "Tile 453: Predicted: [[5.0017506e-01 6.2630999e-01]\n", + " [3.1102818e-09 6.7008492e-09]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 454: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 455: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 456: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 457: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 458: Predicted: [[8.7039524e-01 4.9657050e-01]\n", + " [5.4976622e-06 1.2262326e-06]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 459: Predicted: [[7.4926120e-01 7.3678785e-07]\n", + " [6.2000773e-08 3.2475256e-10]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 460: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 461: Predicted: [[6.2697399e-01 4.9675447e-01]\n", + " [6.3920494e-11 4.3892005e-11]], True: [[0.625 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 462: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 463: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 464: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 465: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 466: Predicted: [[6.3254559e-01 1.2587267e-01]\n", + " [1.3719537e-09 1.0555828e-10]], True: [[0.625 0.125]\n", + " [0. 0. ]]\n", + "Tile 467: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 468: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 469: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 470: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 471: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 472: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 473: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 474: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 475: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 476: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 477: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 478: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 479: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 480: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 481: Predicted: [[0.7497964 0.87540257]\n", + " [0.6563525 0.8422168 ]], True: [[0.75 0.875]\n", + " [0.625 0.875]]\n", + "Tile 482: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 483: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 484: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 485: Predicted: [[2.4606220e-01 1.3069469e-01]\n", + " [3.3556193e-05 1.5154692e-05]], True: [[0.25 0.125]\n", + " [0. 0. ]]\n", + "Tile 486: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 487: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 488: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 489: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 490: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 491: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 492: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 493: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 494: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 495: Predicted: [[2.5089476e-01 8.7780875e-01]\n", + " [2.4941734e-08 3.4284457e-07]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 496: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 497: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 498: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 499: Predicted: [[1.2929064e-01 8.7743336e-01]\n", + " [8.9530516e-21 1.4826615e-19]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 500: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 501: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 502: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 503: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 504: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 505: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 506: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 507: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 508: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 509: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 510: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 511: Predicted: [[1.2549226e-01 1.6036544e-04]\n", + " [4.0374859e-15 5.7697416e-17]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 512: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 513: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 514: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 515: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 516: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 517: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 518: Predicted: [[2.4886039e-01 2.5244540e-01]\n", + " [3.3260326e-07 2.6307825e-07]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 519: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 520: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 521: Predicted: [[5.0110841e-01 7.5182831e-01]\n", + " [5.4996099e-07 2.1232045e-06]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 522: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 523: Predicted: [[2.4886039e-01 2.5244540e-01]\n", + " [3.3260326e-07 2.6307825e-07]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 524: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 525: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 526: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 527: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 528: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 529: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 530: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 531: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 532: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 533: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 534: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 535: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 536: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 537: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 538: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 539: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 540: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 541: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 542: Predicted: [[4.9824399e-01 7.5110126e-01]\n", + " [3.2777641e-13 6.7520642e-13]], True: [[0.5 0.75]\n", + " [0. 0. ]]\n", + "Tile 543: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 544: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 545: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 546: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 547: Predicted: [[6.2102526e-01 2.4899058e-01]\n", + " [2.1521066e-04 4.2915959e-05]], True: [[0.625 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 548: Predicted: [[1.8871921e-03 2.5214130e-01]\n", + " [4.0701798e-05 6.5140077e-04]], True: [[0. 0.25]\n", + " [0. 0. ]]\n", + "Tile 549: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 550: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 551: Predicted: [[3.1420742e-03 4.9609739e-01]\n", + " [9.2912569e-07 5.9589478e-05]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 552: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 553: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 554: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 555: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 556: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 557: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 558: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 559: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 560: Predicted: [[5.0102812e-01 2.5289038e-01]\n", + " [2.1090395e-12 4.9852640e-13]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 561: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 562: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 563: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 564: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 565: Predicted: [[0.5450259 0.42735833]\n", + " [0.5671982 0.42094547]], True: [[0.625 0.125]\n", + " [0.5 0.75 ]]\n", + "Tile 566: Predicted: [[0.5336355 0.5800728]\n", + " [0.7114071 0.6447821]], True: [[0.375 0.375]\n", + " [0.875 0.875]]\n", + "Tile 567: Predicted: [[2.5051054e-01 5.0055176e-01]\n", + " [5.8824007e-15 8.7736503e-15]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 568: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 569: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 570: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 571: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 572: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 573: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 574: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 575: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 576: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 577: Predicted: [[5.01869828e-04 6.03021879e-04]\n", + " [2.13671442e-12 1.39067915e-11]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 578: Predicted: [[5.0017506e-01 6.2630999e-01]\n", + " [3.1102818e-09 6.7008492e-09]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 579: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 580: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 581: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 582: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 583: Predicted: [[8.7400442e-01 1.2699872e-01]\n", + " [8.2201780e-08 5.0394422e-09]], True: [[0.875 0.125]\n", + " [0. 0. ]]\n", + "Tile 584: Predicted: [[7.5369906e-01 4.9389994e-01]\n", + " [8.1189569e-08 2.8317295e-08]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 585: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 586: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 587: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 588: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 589: Predicted: [[2.5089476e-01 8.7780875e-01]\n", + " [2.4941734e-08 3.4284457e-07]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 590: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 591: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 592: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 593: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 594: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 595: Predicted: [[6.2734783e-01 5.9939816e-04]\n", + " [1.2920746e-10 3.5077117e-13]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 596: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 597: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 598: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 599: Predicted: [[8.8086069e-01 6.2502652e-01]\n", + " [2.9353957e-17 3.9358962e-18]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 600: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 601: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 602: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 603: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 604: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 605: Predicted: [[0.4261062 0.6499689 ]\n", + " [0.27176574 0.5321187 ]], True: [[0.125 0.375]\n", + " [0.625 0.75 ]]\n", + "Tile 606: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 607: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 608: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 609: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 610: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 611: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 612: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 613: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 614: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 615: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 616: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 617: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 618: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 619: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 620: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 621: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 622: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 623: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 624: Predicted: [[5.0277382e-01 6.2598670e-01]\n", + " [2.4116009e-08 3.2351515e-08]], True: [[0.5 0.625]\n", + " [0. 0. ]]\n", + "Tile 625: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 626: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 627: Predicted: [[2.4865903e-01 6.2434858e-01]\n", + " [3.8695064e-14 8.5702333e-14]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 628: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 629: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 630: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 631: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 632: Predicted: [[8.7532055e-01 3.7610188e-01]\n", + " [6.0160536e-19 3.6371070e-20]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 633: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 634: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 635: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 636: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 637: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 638: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 639: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 640: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 641: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 642: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 643: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 644: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 645: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 646: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 647: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 648: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 649: Predicted: [[1.2131299e-01 2.2224499e-06]\n", + " [1.2624476e-07 1.3595004e-08]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 650: Predicted: [[1.2686120e-03 6.1855143e-01]\n", + " [2.4361670e-09 4.1626069e-07]], True: [[0. 0.625]\n", + " [0. 0. ]]\n", + "Tile 651: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 652: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 653: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 654: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 655: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 656: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 657: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 658: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 659: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 660: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 661: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 662: Predicted: [[4.2091551e-06 7.6305664e-01]\n", + " [7.2256634e-21 7.2267182e-19]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 663: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 664: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 665: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 666: Predicted: [[2.5051054e-01 5.0055176e-01]\n", + " [5.8824007e-15 8.7736503e-15]], True: [[0.25 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 667: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 668: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 669: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 670: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 671: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 672: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 673: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 674: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 675: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 676: Predicted: [[7.4926120e-01 7.3678785e-07]\n", + " [6.2000773e-08 3.2475256e-10]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 677: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 678: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 679: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 680: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 681: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 682: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 683: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 684: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 685: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 686: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 687: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 688: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 689: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 690: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 691: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 692: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 693: Predicted: [[2.8206867e-05 3.8382447e-01]\n", + " [5.7517273e-15 5.5375822e-14]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 694: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 695: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 696: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 697: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 698: Predicted: [[7.5306123e-01 4.9922931e-01]\n", + " [9.3528683e-12 2.7043955e-12]], True: [[0.75 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 699: Predicted: [[2.48050332e-01 7.69941980e-05]\n", + " [2.21744445e-09 1.02990715e-11]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 700: Predicted: [[8.7532055e-01 3.7610188e-01]\n", + " [6.0160536e-19 3.6371070e-20]], True: [[0.875 0.375]\n", + " [0. 0. ]]\n", + "Tile 701: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 702: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 703: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 704: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 705: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 706: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 707: Predicted: [[4.9910015e-01 2.5150302e-01]\n", + " [9.7755083e-06 3.2932528e-06]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 708: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 709: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 710: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 711: Predicted: [[3.7230673e-01 4.5961334e-04]\n", + " [1.2089343e-04 5.2653236e-06]], True: [[0.375 0. ]\n", + " [0. 0. ]]\n", + "Tile 712: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 713: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 714: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 715: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 716: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 717: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 718: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 719: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 720: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 721: Predicted: [[1.2288860e-01 1.2624377e-01]\n", + " [6.4002589e-15 7.1142577e-15]], True: [[0.125 0.125]\n", + " [0. 0. ]]\n", + "Tile 722: Predicted: [[8.80595386e-01 5.00807047e-01]\n", + " [8.48523563e-13 1.02942496e-13]], True: [[0.875 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 723: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 724: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 725: Predicted: [[5.0102812e-01 2.5289038e-01]\n", + " [2.1090395e-12 4.9852640e-13]], True: [[0.5 0.25]\n", + " [0. 0. ]]\n", + "Tile 726: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 727: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 728: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 729: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 730: Predicted: [[1.3210741e-01 6.2648559e-01]\n", + " [2.8016887e-18 1.6745299e-17]], True: [[0.125 0.625]\n", + " [0. 0. ]]\n", + "Tile 731: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 732: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 733: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 734: Predicted: [[1.2549226e-01 1.6036544e-04]\n", + " [4.0374859e-15 5.7697416e-17]], True: [[0.125 0. ]\n", + " [0. 0. ]]\n", + "Tile 735: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 736: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 737: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 738: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 739: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 740: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 741: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 742: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 743: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 744: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 745: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 746: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 747: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 748: Predicted: [[7.4860644e-01 2.5049281e-01]\n", + " [6.9498572e-05 1.1066318e-05]], True: [[0.75 0.25]\n", + " [0. 0. ]]\n", + "Tile 749: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 750: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 751: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 752: Predicted: [[0.1258 0.3780244 ]\n", + " [0.12167133 0.3762547 ]], True: [[0. 0.25]\n", + " [0.25 0.5 ]]\n", + "Tile 753: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 754: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 755: Predicted: [[5.0350279e-01 1.2788108e-01]\n", + " [7.6633860e-10 1.0626289e-10]], True: [[0.5 0.125]\n", + " [0. 0. ]]\n", + "Tile 756: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 757: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 758: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 759: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 760: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 761: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 762: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 763: Predicted: [[4.99921560e-01 4.97585803e-01]\n", + " [1.14282876e-08 1.01964135e-08]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 764: Predicted: [[1.2929064e-01 8.7743336e-01]\n", + " [8.9530516e-21 1.4826615e-19]], True: [[0.125 0.875]\n", + " [0. 0. ]]\n", + "Tile 765: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 766: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 767: Predicted: [[1.2357616e-05 5.1174736e-01]\n", + " [3.9506272e-12 7.3166771e-11]], True: [[0. 0.5]\n", + " [0. 0. ]]\n", + "Tile 768: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 769: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 770: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 771: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 772: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 773: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 774: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 775: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 776: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 777: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 778: Predicted: [[0.64146394 0.44383013]\n", + " [0.6022558 0.42531464]], True: [[0.5 0.625]\n", + " [0.75 0.25 ]]\n", + "Tile 779: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 780: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 781: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 782: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 783: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 784: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 785: Predicted: [[1.2345693e-01 5.0697517e-01]\n", + " [8.6775792e-17 3.1683688e-16]], True: [[0.125 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 786: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 787: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 788: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 789: Predicted: [[1.21737674e-01 3.79419237e-01]\n", + " [1.80331959e-13 5.59754012e-13]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 790: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 791: Predicted: [[3.8162413e-01 4.9975181e-01]\n", + " [8.7047844e-13 8.5942017e-13]], True: [[0.375 0.5 ]\n", + " [0. 0. ]]\n", + "Tile 792: Predicted: [[7.5264323e-01 1.2956496e-01]\n", + " [3.8601657e-11 1.4229026e-12]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 793: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 794: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 795: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 796: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 797: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 798: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 799: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 800: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 801: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 802: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 803: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 804: Predicted: [[5.4404006e-04 3.7546444e-01]\n", + " [1.2051814e-08 6.4150203e-07]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 805: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 806: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 807: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 808: Predicted: [[6.7968614e-04 7.4627775e-01]\n", + " [7.8466215e-08 1.5853233e-05]], True: [[0. 0.75]\n", + " [0. 0. ]]\n", + "Tile 809: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 810: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 811: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 812: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 813: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 814: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 815: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 816: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 817: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 818: Predicted: [[2.48050332e-01 7.69941980e-05]\n", + " [2.21744445e-09 1.02990715e-11]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 819: Predicted: [[2.4865903e-01 6.2434858e-01]\n", + " [3.8695064e-14 8.5702333e-14]], True: [[0.25 0.625]\n", + " [0. 0. ]]\n", + "Tile 820: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 821: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 822: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 823: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 824: Predicted: [[5.1031840e-01 6.6823879e-05]\n", + " [1.1857227e-12 2.0964586e-15]], True: [[0.5 0. ]\n", + " [0. 0. ]]\n", + "Tile 825: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 826: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 827: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 828: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 829: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 830: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 831: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 832: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 833: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 834: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 835: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 836: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 837: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 838: Predicted: [[7.4926120e-01 7.3678785e-07]\n", + " [6.2000773e-08 3.2475256e-10]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 839: Predicted: [[3.6954030e-01 1.2560870e-01]\n", + " [6.4141426e-04 1.6775219e-04]], True: [[0.375 0.125]\n", + " [0. 0. ]]\n", + "Tile 840: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 841: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 842: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 843: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 844: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 845: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 846: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 847: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 848: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 849: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 850: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 851: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 852: Predicted: [[1.1910531e-01 7.5485933e-01]\n", + " [2.0206304e-18 1.7182666e-17]], True: [[0.125 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 853: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 854: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 855: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 856: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 857: Predicted: [[7.5147665e-01 6.1706422e-05]\n", + " [9.9940991e-14 4.6818108e-17]], True: [[0.75 0. ]\n", + " [0. 0. ]]\n", + "Tile 858: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 859: Predicted: [[2.4846141e-01 8.7407380e-01]\n", + " [6.3684430e-14 3.9657999e-13]], True: [[0.25 0.875]\n", + " [0. 0. ]]\n", + "Tile 860: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 861: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 862: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 863: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 864: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 865: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 866: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 867: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 868: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 869: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 870: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 871: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 872: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 873: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 874: Predicted: [[3.7442595e-01 7.5275952e-01]\n", + " [3.6405586e-06 1.5372232e-05]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 875: Predicted: [[2.4969275e-01 7.5095600e-01]\n", + " [2.6954540e-06 1.5264071e-05]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 876: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 877: Predicted: [[3.7529725e-01 6.2449604e-01]\n", + " [7.3330453e-09 2.1153566e-08]], True: [[0.375 0.625]\n", + " [0. 0. ]]\n", + "Tile 878: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 879: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 880: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 881: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 882: Predicted: [[0.394082 0.26738286]\n", + " [0.34531993 0.24855323]], True: [[0. 0.125]\n", + " [0.75 0.375]]\n", + "Tile 883: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 884: Predicted: [[3.7822327e-01 2.4915342e-01]\n", + " [6.6363150e-08 3.3251315e-08]], True: [[0.375 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 885: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 886: Predicted: [[8.8484251e-01 8.7592053e-01]\n", + " [1.7661547e-17 5.5449159e-18]], True: [[0.875 0.875]\n", + " [0. 0. ]]\n", + "Tile 887: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 888: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 889: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 890: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 891: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 892: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 893: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 894: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 895: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 896: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 897: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 898: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 899: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 900: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 901: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 902: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 903: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 904: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 905: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 906: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 907: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 908: Predicted: [[6.2967515e-01 8.6975658e-01]\n", + " [6.1289660e-07 2.0044629e-06]], True: [[0.625 0.875]\n", + " [0. 0. ]]\n", + "Tile 909: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 910: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 911: Predicted: [[3.7442595e-01 7.5275952e-01]\n", + " [3.6405586e-06 1.5372232e-05]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 912: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 913: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 914: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 915: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 916: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 917: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 918: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 919: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 920: Predicted: [[6.2734783e-01 5.9939816e-04]\n", + " [1.2920746e-10 3.5077117e-13]], True: [[0.625 0. ]\n", + " [0. 0. ]]\n", + "Tile 921: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 922: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 923: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 924: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 925: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 926: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 927: Predicted: [[0.8104064 0.3948693 ]\n", + " [0.8292201 0.38631725]], True: [[0.75 0.5 ]\n", + " [0.875 0.25 ]]\n", + "Tile 928: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 929: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 930: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 931: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 932: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 933: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 934: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 935: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 936: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 937: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 938: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 939: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 940: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 941: Predicted: [[5.0174540e-01 4.9891648e-01]\n", + " [6.6390342e-09 8.2156912e-09]], True: [[0.5 0.5]\n", + " [0. 0. ]]\n", + "Tile 942: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 943: Predicted: [[2.4803667e-01 2.2548284e-05]\n", + " [3.6378549e-07 2.1588731e-08]], True: [[0.25 0. ]\n", + " [0. 0. ]]\n", + "Tile 944: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 945: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 946: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 947: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 948: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 949: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 950: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 951: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 952: Predicted: [[2.4945782e-01 2.5285539e-01]\n", + " [4.0789327e-09 4.8504996e-09]], True: [[0.25 0.25]\n", + " [0. 0. ]]\n", + "Tile 953: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 954: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 955: Predicted: [[3.7056655e-01 7.4863881e-01]\n", + " [1.8702304e-09 4.9766862e-09]], True: [[0.375 0.75 ]\n", + " [0. 0. ]]\n", + "Tile 956: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 957: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 958: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 959: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 960: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 961: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 962: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 963: Predicted: [[3.7823945e-01 8.7176055e-01]\n", + " [3.1127118e-11 2.4505475e-10]], True: [[0.375 0.875]\n", + " [0. 0. ]]\n", + "Tile 964: Predicted: [[5.4404006e-04 3.7546444e-01]\n", + " [1.2051814e-08 6.4150203e-07]], True: [[0. 0.375]\n", + " [0. 0. ]]\n", + "Tile 965: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 966: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 967: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 968: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 969: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 970: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 971: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 972: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 973: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 974: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 975: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 976: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 977: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 978: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 979: Predicted: [[0.7138456 0.77725524]\n", + " [0.76683503 0.7814397 ]], True: [[0.625 0.875]\n", + " [0.75 0.875]]\n", + "Tile 980: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 981: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 982: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 983: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 984: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 985: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 986: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 987: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 988: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 989: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 990: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 991: Predicted: [[2.5215873e-01 7.5172102e-01]\n", + " [8.5552697e-11 3.9774264e-10]], True: [[0.25 0.75]\n", + " [0. 0. ]]\n", + "Tile 992: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 993: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 994: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 995: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 996: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 997: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 998: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 999: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1000: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1001: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1002: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1003: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1004: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1005: Predicted: [[8.7087965e-01 6.2128061e-01]\n", + " [5.2493997e-06 1.6517998e-06]], True: [[0.875 0.625]\n", + " [0. 0. ]]\n", + "Tile 1006: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1007: Predicted: [[1.0958408e-08 8.0479487e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1008: Predicted: [[7.5264323e-01 1.2956496e-01]\n", + " [3.8601657e-11 1.4229026e-12]], True: [[0.75 0.125]\n", + " [0. 0. ]]\n", + "Tile 1009: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1010: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1011: Predicted: [[1.21737674e-01 3.79419237e-01]\n", + " [1.80331959e-13 5.59754012e-13]], True: [[0.125 0.375]\n", + " [0. 0. ]]\n", + "Tile 1012: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1013: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1014: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1015: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1016: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1017: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1018: Predicted: [[6.0885185e-07 1.2487493e-01]\n", + " [2.1627106e-15 1.7094855e-14]], True: [[0. 0.125]\n", + " [0. 0. ]]\n", + "Tile 1019: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1020: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1021: Predicted: [[1.2019656e-01 2.5231454e-01]\n", + " [7.5606145e-16 8.0718772e-16]], True: [[0.125 0.25 ]\n", + " [0. 0. ]]\n", + "Tile 1022: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n", + "Tile 1023: Predicted: [[7.9176715e-08 1.3941063e-07]\n", + " [0.0000000e+00 0.0000000e+00]], True: [[0. 0.]\n", + " [0. 0.]]\n" + ] + } + ], + "source": [ + "# Choose an image index (you can loop or set it explicitly)\n", + "image_index = np.random.randint(0, 120) # Randomly pick an image in the batch\n", + "\n", + "# Get predictions and targets for the selected image\n", + "predicted_image = predicted_centers[image_index]\n", + "true_targets_image = grouped_targets[image_index]\n", + "\n", + "# Print all predictions and true targets for the selected image\n", + "print(f\"Predictions for image index {image_index}:\")\n", + "for tile_idx, (pred, true) in enumerate(zip(predicted_image, true_targets_image)):\n", + " print(f\"Tile {tile_idx}: Predicted: {pred}, True: {true}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Positives (TP): 195\n", + "False Positives (FP): 0\n", + "False Negatives (FN): 0\n", + "Precision: 1.0000, Recall: 1.0000\n" + ] + } + ], + "source": [ + "TP, FP, FN = 0, 0, 0\n", + "threshold = 0.1 \n", + "tile_size = 8\n", + "\n", + "\n", + "\n", + "for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + " # Filter valid hits\n", + " valid_predicted_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in pred_hits\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size)\n", + " ]\n", + " valid_true_hits = [\n", + " (x * tile_size, y * tile_size) for x, y in true_hits\n", + " if (x, y) != (0, 0)\n", + " ]\n", + "\n", + " \n", + " # Match predictions to true hits\n", + " matched_true_hits = set()\n", + " for pred in valid_predicted_hits:\n", + " for i, true_hit in enumerate(valid_true_hits):\n", + " if i in matched_true_hits:\n", + " continue\n", + " distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + " if distance <= 1 * tile_size:\n", + " TP += 1\n", + " matched_true_hits.add(i)\n", + " break\n", + " else:\n", + " FP += 1\n", + "\n", + " FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# Precision and Recall\n", + "precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "print(f\"True Positives (TP): {TP}\")\n", + "print(f\"False Positives (FP): {FP}\")\n", + "print(f\"False Negatives (FN): {FN}\")\n", + "print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# if i in matched_true_hits:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(pred_idx)\n", + "# break\n", + "# else:\n", + "# FP += 1\n", + "\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "\n", + "# TP, FP, FN = 0, 0, 0\n", + "# threshold = 0.1\n", + "# tile_size = 8\n", + "\n", + "# for tile_idx, (pred_hits, true_hits) in enumerate(zip(predicted_image, true_targets_image)):\n", + "# valid_predicted_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in pred_hits\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size and y >= threshold / tile_size)\n", + "# ]\n", + "# valid_true_hits = [\n", + "# (x * tile_size, y * tile_size) for x, y in true_hits\n", + "# if (x, y) != (0, 0)\n", + "# ]\n", + "\n", + "# matched_true_hits = set()\n", + "# matched_predictions = set()\n", + "\n", + "# for i, true_hit in enumerate(valid_true_hits):\n", + "# # Find the closest prediction within the threshold\n", + "# min_distance = float('inf')\n", + "# closest_pred_idx = -1\n", + "\n", + "# for pred_idx, pred in enumerate(valid_predicted_hits):\n", + "# if pred_idx in matched_predictions:\n", + "# continue\n", + "# distance = np.sqrt((pred[0] - true_hit[0])**2 + (pred[1] - true_hit[1])**2)\n", + "# if distance <= 1 * tile_size and distance < min_distance:\n", + "# min_distance = distance\n", + "# closest_pred_idx = pred_idx\n", + "\n", + "# # If a match is found, update TP and mark the prediction as matched\n", + "# if closest_pred_idx != -1:\n", + "# TP += 1\n", + "# matched_true_hits.add(i)\n", + "# matched_predictions.add(closest_pred_idx)\n", + "\n", + "# # Remaining unmatched predictions are False Positives\n", + "# FP += len(valid_predicted_hits) - len(matched_predictions)\n", + "\n", + "# # Remaining unmatched true hits are False Negatives\n", + "# FN += len(valid_true_hits) - len(matched_true_hits)\n", + "\n", + "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + "# recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + "\n", + "# print(f\"True Positives (TP): {TP}\")\n", + "# print(f\"False Positives (FP): {FP}\")\n", + "# print(f\"False Negatives (FN): {FN}\")\n", + "# print(f\"Precision: {precision:.4f}, Recall: {recall:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from its tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - reconstructed_image: np.array, the reconstructed image.\n", + " \"\"\"\n", + " # Calculate the number of rows/columns in the original image\n", + " num_rows = num_tiles_per_row * tile_size\n", + " reconstructed_image = np.zeros((num_rows, num_rows))\n", + "\n", + " # Place each tile in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage\n", + "tiles = np.random.random((4, 8, 8)) # Create 4 random tiles of size 8x8\n", + "reconstructed_image = reconstruct_image_from_tiles(tiles, tile_size=8, num_tiles_per_row=2)\n", + "\n", + "# Plotting\n", + "fig, ax = plt.subplots(1, 5, figsize=(15, 3))\n", + "for i in range(4):\n", + " ax[i].imshow(tiles[i], cmap='gray')\n", + " ax[i].set_title(f\"Tile {i}\")\n", + " ax[i].axis('off')\n", + "\n", + "ax[4].imshow(reconstructed_image, cmap='gray')\n", + "ax[4].set_title(\"Reconstructed Image\")\n", + "ax[4].axis('off')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.1):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example: Visualize for one image\n", + "image_index = 12 # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for this image\n", + "visualize_image_with_predictions(image_tiles, predicted_centers[image_index], grouped_targets[image_index])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_predictions(image_tiles, predicted_image, true_targets_image, tile_size=8, threshold=0.05):\n", + " \"\"\"\n", + " Visualize a reconstructed image with overlaid predictions and true centers.\n", + "\n", + " Parameters:\n", + " - image_tiles: Tiles of the image (flattened input tiles).\n", + " - predicted_image: Predictions for the image (grouped by tiles).\n", + " - true_targets_image: True targets for the image (grouped by tiles).\n", + " - tile_size: Size of each tile (default: 8).\n", + " - threshold: Threshold for filtering predictions.\n", + " \"\"\"\n", + " # Calculate grid size dynamically\n", + " num_tiles_per_image = predicted_image.shape[0]\n", + " grid_size = int(np.sqrt(num_tiles_per_image))\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, num_tiles_per_row=grid_size\n", + " )\n", + "\n", + " # Visualize the reconstructed image\n", + " plt.figure(figsize=(15, 15))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(\"Reconstructed Image with Predictions and True Hits\")\n", + "\n", + " # Overlay grid lines for tiles\n", + " for i in range(1, grid_size):\n", + " plt.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " plt.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true centers (green)\n", + " for tile_idx, true_hits in enumerate(true_targets_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in true_hits:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='green', label='True Hits' if tile_idx == 0 else \"\", marker='x', s=10)\n", + "\n", + " # Overlay predicted centers (red)\n", + " for tile_idx, predicted_hits in enumerate(predicted_image):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " for (x, y) in predicted_hits:\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): # Ignore padding\n", + " plt.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " color='red', label='Predicted Hits' if tile_idx == 0 else \"\", marker='o', s=5)\n", + "\n", + " # Add a legend\n", + " handles, labels = plt.gca().get_legend_handles_labels()\n", + " by_label = dict(zip(labels, handles)) # Remove duplicate labels\n", + " plt.legend(by_label.values(), by_label.keys(), loc='upper right')\n", + "\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Example usage\n", + "image_index = 0 # Select an image index\n", + "image_tiles = inputs[image_index * 1024:(image_index + 1) * 1024] # Extract tiles for the image\n", + "\n", + "visualize_image_with_predictions(\n", + " image_tiles,\n", + " predicted_image=predicted_centers[image_index],\n", + " true_targets_image=grouped_targets[image_index],\n", + " tile_size=8,\n", + " threshold=0.2\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First image's first tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n", + "First image's second tile:\n", + "tf.Tensor(\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]], shape=(8, 1), dtype=float64)\n" + ] + } + ], + "source": [ + "for val_images, val_centers in val_dataset.take(1):\n", + " print(\"First image's first tile:\")\n", + " print(val_images[0, 0]) # Tile 0 of Image 0\n", + " print(\"First image's second tile:\")\n", + " print(val_images[0, 1]) # Tile 1 of Image 0\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Electron Counting Tiling approach/256 by 256 images uneven tiling.ipynb b/Electron Counting Tiling approach/256 by 256 images uneven tiling.ipynb new file mode 100644 index 0000000..a0ae9b4 --- /dev/null +++ b/Electron Counting Tiling approach/256 by 256 images uneven tiling.ipynb @@ -0,0 +1,1241 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-17 16:34:49.450185: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-17 16:34:49.462897: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-17 16:34:49.475663: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-17 16:34:49.479516: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-17 16:34:49.490339: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-17 16:34:50.121293: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-17 16:34:51.815170: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 78267 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-17 16:34:51.816623: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79196 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-17 16:34:51.817950: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-19 17:47:38.687834: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-19 17:47:38.702527: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-19 17:47:38.714858: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-19 17:47:38.718638: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-19 17:47:38.730159: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-19 17:47:39.375587: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import h5py\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=9, stride=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.stride = stride\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:100])\n", + " centers = np.array(f['centers_training'][:100])\n", + " return images, centers\n", + "\n", + " def tile_image_with_overlap(self, image):\n", + " \"\"\"\n", + " Splits an image into overlapping tiles using a sliding window.\n", + "\n", + " Parameters:\n", + " - image: np.array, the input image (2D array).\n", + "\n", + " Returns:\n", + " - tiles: np.array, containing all tiles as a 3D array (num_tiles, tile_size, tile_size).\n", + " - tile_positions: list of tuples, containing the (row_start, col_start) positions of each tile.\n", + " \"\"\"\n", + " tiles = []\n", + " tile_positions = []\n", + " for row in range(0, image.shape[0] - self.tile_size + 1, self.stride):\n", + " for col in range(0, image.shape[1] - self.tile_size + 1, self.stride):\n", + " tile = image[row:row + self.tile_size, col:col + self.tile_size]\n", + " tiles.append(tile)\n", + " tile_positions.append((row, col))\n", + " \n", + " # Ensure the last row/column are covered\n", + " if (image.shape[0] - self.tile_size) % self.stride != 0:\n", + " for col in range(0, image.shape[1] - self.tile_size + 1, self.stride):\n", + " tile = image[-self.tile_size:, col:col + self.tile_size]\n", + " tiles.append(tile)\n", + " tile_positions.append((image.shape[0] - self.tile_size, col))\n", + " if (image.shape[1] - self.tile_size) % self.stride != 0:\n", + " for row in range(0, image.shape[0] - self.tile_size + 1, self.stride):\n", + " tile = image[row:row + self.tile_size, -self.tile_size:]\n", + " tiles.append(tile)\n", + " tile_positions.append((row, image.shape[1] - self.tile_size))\n", + " if (image.shape[0] - self.tile_size) % self.stride != 0 and (image.shape[1] - self.tile_size) % self.stride != 0:\n", + " tile = image[-self.tile_size:, -self.tile_size:]\n", + " tiles.append(tile)\n", + " tile_positions.append((image.shape[0] - self.tile_size, image.shape[1] - self.tile_size))\n", + "\n", + " return np.array(tiles), tile_positions\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles, tile_positions = self.tile_image_with_overlap(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " for tile_idx, (row_start, col_start) in enumerate(tile_positions):\n", + " if row_start <= y < row_start + self.tile_size and col_start <= x < col_start + self.tile_size:\n", + " local_x = x - col_start\n", + " local_y = y - row_start\n", + " hits_per_tile[tile_idx].append((local_x, local_y))\n", + " break\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + "\n", + " # Normalize coordinates to be within the range [0, 1] based on tile size\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " return normalized_images, np.array(normalized_centers)\n", + "\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + " \"\"\"\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " flat_centers = []\n", + " for img_centers in centers:\n", + " for tile_centers in img_centers:\n", + " tile_centers = list(tile_centers)\n", + " tile_centers = tile_centers[:max_hits_per_tile] + [(0, 0)] * (max_hits_per_tile - len(tile_centers))\n", + " flat_centers.append([coord for hit in tile_centers for coord in hit])\n", + "\n", + " flat_centers = np.array(flat_centers)\n", + " return flat_images, flat_centers\n", + "\n", + "\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " train_images_flat, train_centers_flat = flatten_dataset(train_images, train_centers, data_loader.tile_size, data_loader.max_hits_per_tile)\n", + " val_images_flat, val_centers_flat = flatten_dataset(val_images, val_centers, data_loader.tile_size, data_loader.max_hits_per_tile)\n", + "\n", + " batch_size = 4000\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers\n", + "\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " tiles, tile_positions = data_loader.tile_image_with_overlap(image)\n", + "\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + "\n", + " for (row, col) in tile_positions:\n", + " plt.gca().add_patch(plt.Rectangle((col, row), data_loader.tile_size, data_loader.tile_size, edgecolor='red', fill=False, lw=0.5))\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + "\n", + " plt.title(f'Image {image_index} with Overlapping Tiles')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + " num_tiles_to_show = min(9, len(tiles))\n", + " plt.figure(figsize=(10, 10))\n", + " for i in range(num_tiles_to_show):\n", + " plt.subplot(3, 3, i + 1)\n", + " plt.imshow(tiles[i], cmap='gray')\n", + " plt.title(f\"Tile {i} at {tile_positions[i]}\")\n", + " plt.axis('on')\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "data_loader = DataLoader(h5_filename='/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_100_256by256_Randomindex.h5', tile_size=9, stride=8, max_hits_per_tile=2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y = np.random.randint(0, len(data_loader.images))\n", + "visualize_image_with_tiles(data_loader, image_index=y)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_100_256by256_Randomindex.h5' ###for training\n", + "# # file_path ='/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5' ###for testing\n", + "# data_loader = DataLoader(file_path, tile_size=4, max_hits_per_tile=5)\n", + "\n", + "# # images, centers = data_loader.normalize_data()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10000, 1024, 5, 2)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create Datasets for Training/Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[19], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Generate the datasets\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m train_dataset, val_dataset, train_images, val_images, train_centers, val_centers \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_datasets\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata_loader\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[3], line 121\u001b[0m, in \u001b[0;36mcreate_datasets\u001b[0;34m(data_loader, train_size)\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_datasets\u001b[39m(data_loader, train_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.8\u001b[39m):\n\u001b[0;32m--> 121\u001b[0m normalized_images, normalized_centers \u001b[38;5;241m=\u001b[39m \u001b[43mdata_loader\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalize_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 122\u001b[0m train_images, val_images, train_centers, val_centers \u001b[38;5;241m=\u001b[39m train_test_split(\n\u001b[1;32m 123\u001b[0m normalized_images, normalized_centers, train_size\u001b[38;5;241m=\u001b[39mtrain_size, random_state\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m42\u001b[39m\n\u001b[1;32m 124\u001b[0m )\n\u001b[1;32m 126\u001b[0m train_images_flat, train_centers_flat \u001b[38;5;241m=\u001b[39m flatten_dataset(train_images, train_centers, data_loader\u001b[38;5;241m.\u001b[39mtile_size, data_loader\u001b[38;5;241m.\u001b[39mmax_hits_per_tile)\n", + "Cell \u001b[0;32mIn[3], line 93\u001b[0m, in \u001b[0;36mDataLoader.normalize_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 92\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mnormalize_data\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m---> 93\u001b[0m tiled_images, tiled_centers \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprocess_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 94\u001b[0m normalized_images \u001b[38;5;241m=\u001b[39m tiled_images \u001b[38;5;241m/\u001b[39m np\u001b[38;5;241m.\u001b[39mmax(tiled_images)\n\u001b[1;32m 96\u001b[0m \u001b[38;5;66;03m# Normalize coordinates to be within the range [0, 1] based on tile size\u001b[39;00m\n", + "Cell \u001b[0;32mIn[3], line 90\u001b[0m, in \u001b[0;36mDataLoader.process_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 84\u001b[0m tile_hits_list \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 85\u001b[0m hits_per_tile[i][:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmax_hits_per_tile] \u001b[38;5;241m+\u001b[39m [(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m)] \u001b[38;5;241m*\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmax_hits_per_tile \u001b[38;5;241m-\u001b[39m \u001b[38;5;28mlen\u001b[39m(hits_per_tile[i]))\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(tiles))\n\u001b[1;32m 87\u001b[0m ]\n\u001b[1;32m 88\u001b[0m tiled_centers\u001b[38;5;241m.\u001b[39mappend(tile_hits_list)\n\u001b[0;32m---> 90\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m np\u001b[38;5;241m.\u001b[39marray(tiled_images), np\u001b[38;5;241m.\u001b[39marray(tiled_centers)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "\n", + "\n", + "# Generate the datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((8000, 4096, 4, 4),\n", + " (2000, 4096, 4, 4),\n", + " (8000, 4096, 5, 2),\n", + " (2000, 4096, 5, 2))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize sample tiles from the dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9QAAAPeCAYAAADtT1LiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZxcRbn//zndPYQEmAmBsEQkrLIIiIYE2YPi5aeQICpK9CJwcVfuRdwvX1lV3O4VNxSviIoCCnrJBFxAJICIJICI7IvARTAgCfSwk8zU74/0aaprqp5azjndM5PP+/U6r0z6nKrnqaqn6tTpfp7zZEopBUIIIYQQQgghhERR67UChBBCCCGEEELIeIQP1IQQQgghhBBCSAJ8oCaEEEIIIYQQQhLgAzUhhBBCCCGEEJIAH6gJIYQQQgghhJAE+EBNCCGEEEIIIYQkwAdqQgghhBBCCCEkAT5QE0IIIYQQQgghCfCBmhBCCCGEEEIISYAP1ISQccnJJ5+MLMuSyv7whz9ElmV44IEHylVK44EHHkCWZfjhD39YmYyJTsw45dfecMMNleo0d+5czJ07t/3/iT7OZnvLohtzcKwxHmzl6aefxkYbbYSf/vSnvVZl3HP77bej0Wjg1ltv7bUqhJCK4QM1IaSr3HbbbfjXf/1XvOxlL8OkSZMwY8YMvOtd78Jtt93Wa9V6wuLFi5FlGS666KJeqzIuOPPMM0t9IMkfckKONenhL5YtttgCBx98sPVcqI3Hjm2WZfjIRz4So2ZXOO+883DGGWf0Wo0kvv71r2O99dbD4Ycf3v4s//Ly8ccf76Fm1SKtAxdccEHHtUuWLMGHPvQhzJo1C319fc4vdnfccUccdNBBOPHEE7vRBEJID2n0WgFCyJrDL3/5SyxYsADTpk3DMcccgy233BIPPPAAzj77bFx00UW44IILcOihhwbV9f/+3//Dpz/96SQ9jjjiCBx++OGYNGlSUnnSHWzjdOaZZ2LDDTfEUUcdVYqM6dOn49xzz+347L/+67/w97//HV/72tdGXXvZZZeVIndNpxtj2yvOO+883HrrrTjuuOM6Pp85cyaee+459PX19UYxDytXrsTXv/51fPSjH0W9Xu+1Oj1hwYIFeNOb3tTx2R577NHx/1/96lf4/ve/j1122QVbbbUV7r77bmd9H/jAB/CmN70J9913H7beeutKdCaE9B4+UBNCusJ9992HI444AltttRWuvvpqTJ8+vX3uP/7jP7DPPvvgiCOOwC233IKtttrKWc8zzzyDddZZB41GA41G2hJWr9fX2A3jeKIb47TOOuvgX//1Xzs+u+CCC/DEE0+M+pyUx5o4B7Msw9prr91rNZxccskl+Oc//4m3v/3tvValZ7zmNa/xzvsPfvCD+NSnPoXJkyfjIx/5iPhAfcABB2D99dfHj370I5x66qllq0sIGSPQ5ZsQ0hW+8pWv4Nlnn8X3vve9jodpANhwww1x1lln4ZlnnsGXv/zl9ue5q+Htt9+Od77znVh//fWx9957d5zTee655/Dv//7v2HDDDbHeeuth/vz5ePjhh5FlGU4++eT2dbb4zdxl9Q9/+APmzJmDtddeG1tttRV+/OMfd8hYsWIFPv7xj2PnnXfGuuuui/7+frzxjW/EX/7yl5J66qW23X333fjXf/1XDAwMYPr06fjsZz8LpRQeeughHHLIIejv78cmm2yC//qv/+oo/+KLL+LEE0/ErFmzMDAwgHXWWQf77LMPrrzyylGyli9fjiOOOAL9/f2YOnUqjjzySPzlL3+xxnreeeedeNvb3oZp06Zh7bXXxm677YbBwUFve17zmtfgLW95S8dnO++8M7Iswy233NL+7Gc/+xmyLMMdd9wBYPQ4bbHFFrjttttw1VVXtd0xzfjeF154AccffzymT5+OddZZB4ceeij++c9/enUMJTSmOKSvVq5ciVNOOQXbbrst1l57bWywwQbYe++9cfnll4t1h9pg7mr985//HJ///Oex2WabYe2118brX/963HvvvaPq/d73voett94akydPxpw5c3DNNdf4OySRlLFN4ZlnnsHHPvYxvPzlL8ekSZOw3Xbb4atf/SqUUqOu/clPfoI5c+ZgypQpWH/99bHvvvt2eCQsXLgQBx10EGbMmIFJkyZh6623xmmnnYbh4eH2NXPnzsWll16KBx98sN2OLbbYAoA7hvr3v/899tlnH6yzzjqYOnUqDjnkkPYcyMnXhHvvvRdHHXUUpk6dioGBARx99NF49tlnO669/PLLsffee2Pq1KlYd911sd122+E///M/vX118cUXY4sttgj6JXXu3LnYaaedcMstt2C//fbDlClTsM0227Td+q+66irsvvvumDx5Mrbbbjv87ne/6yj/4IMP4kMf+hC22247TJ48GRtssAEOO+wwa1hFLmPy5MnYbLPN8LnPfQ7nnHOONQzj17/+dbsv11tvPRx00EHR4UTPPPMMXnzxRef5jTfeGJMnTw6qq6+vD3PnzsXChQujdCCEjC/4CzUhpCssWrQIW2yxBfbZZx/r+X333RdbbLEFLr300lHnDjvsMGy77bb4whe+YN0I5xx11FH4+c9/jiOOOAKvfe1rcdVVV+Gggw4K1vHee+/F2972NhxzzDE48sgj8YMf/ABHHXUUZs2ahVe+8pUAgL/97W+4+OKLcdhhh2HLLbfEo48+irPOOgv77bcfbr/9dsyYMSNYno93vOMd2GGHHfDFL34Rl156KT73uc9h2rRpOOuss/C6170OX/rSl/DTn/4UH//4xzF79mzsu+++AIChoSF8//vfx4IFC/De974XTz31FM4++2wceOCBWLJkCXbddVcAwMjICObNm4clS5bggx/8ILbffnssXLgQRx555ChdbrvtNuy111542ctehk9/+tNYZ5118POf/xxvfvOb8Ytf/EJ01d9nn31w/vnnt/+/YsUK3HbbbajVarjmmmuwyy67AACuueYaTJ8+HTvssIO1njPOOAPHHnss1l13XZxwwgkAVm9udY499lisv/76OOmkk/DAAw/gjDPOwEc+8hH87Gc/C+/4goT21cknn4zTTz8d73nPezBnzhwMDQ3hhhtuwE033YQ3vOENzvpjbfCLX/wiarUaPv7xj6PZbOLLX/4y3vWud+H6669vX3P22Wfj/e9/P/bcc08cd9xx+Nvf/ob58+dj2rRpePnLXx7U7pUrV1rjbJvNprdsyNjGopTC/PnzceWVV+KYY47Brrvuit/+9rf4xCc+gYcffrjDpf+UU07BySefjD333BOnnnoq1lprLVx//fX4/e9/j3/5l38BsPpLgHXXXRfHH3881l13Xfz+97/HiSeeiKGhIXzlK18BAJxwwgloNpsdIQPrrruuU8ff/e53eOMb34itttoKJ598Mp577jl885vfxF577YWbbrqp/TCe8/a3vx1bbrklTj/9dNx00034/ve/j4022ghf+tKXAKy2vYMPPhi77LILTj31VEyaNAn33nsvrr32Wm9//fGPf8RrXvOa4P594okncPDBB+Pwww/HYYcdhu985zs4/PDD8dOf/hTHHXccPvCBD+Cd73wnvvKVr+Btb3sbHnroIay33noAgKVLl+KPf/wjDj/8cGy22WZ44IEH8J3vfAdz587F7bffjilTpgAAHn74Yey///7Isgyf+cxnsM466+D73/++NVzn3HPPxZFHHokDDzwQX/rSl/Dss8/iO9/5Dvbee2/8+c9/HtWXNk455RR84hOfQJZlmDVrFj7/+c+3xz+VWbNmYeHChRgaGkJ/f3+hugghYxRFCCEV8+STTyoA6pBDDhGvmz9/vgKghoaGlFJKnXTSSQqAWrBgwahr83M5N954owKgjjvuuI7rjjrqKAVAnXTSSe3PzjnnHAVA3X///e3PZs6cqQCoq6++uv3ZY489piZNmqQ+9rGPtT97/vnn1fDwcIeM+++/X02aNEmdeuqpHZ8BUOecc47Y5iuvvFIBUBdeeOGotr3vfe9rf7Zq1Sq12WabqSzL1Be/+MX250888YSaPHmyOvLIIzuufeGFFzrkPPHEE2rjjTdW//Zv/9b+7Be/+IUCoM4444z2Z8PDw+p1r3vdKN1f//rXq5133lk9//zz7c9GRkbUnnvuqbbddluxjRdeeKECoG6//XallFKDg4Nq0qRJav78+eod73hH+7pddtlFHXrooe3/28bpla98pdpvv/1GycivPeCAA9TIyEj7849+9KOqXq+rJ598UtRR56CDDlIzZ860nttvv/065NvGObSvXvWqV6mDDjooWK+cUBvMbWuHHXbosIevf/3rCoD661//qpRS6sUXX1QbbbSR2nXXXTuu+973vqcAWPvbJJ8/0qHbeMzYugCgPvzhDzvPX3zxxQqA+tznPtfx+dve9jaVZZm69957lVJK3XPPPapWq6lDDz10VL/qtvTss8+OkvH+979fTZkypWOsXfZjs5Vdd91VbbTRRmr58uXtz/7yl7+oWq2m3v3ud7c/y9cEff4qpdShhx6qNthgg/b/v/a1rykA6p///KetS5ysXLlSZVnWsdaZsvU699tvPwVAnXfeee3P7rzzTgVA1Wo19ac//an9+W9/+9tR7bb15XXXXacAqB//+Mftz4499liVZZn685//3P5s+fLlatq0aR3289RTT6mpU6eq9773vR11Llu2TA0MDIz63OTBBx9U//Iv/6K+853vqMHBQXXGGWeozTffXNVqNXXJJZc4y334wx/uuA/ZOO+88xQAdf3114vXEULGL3T5JoRUzlNPPQUA7V8nXOTnh4aGOj7/wAc+4JXxm9/8BgDwoQ99qOPzY489NljPHXfcseMX9OnTp2O77bbD3/72t/ZnkyZNQq22eukcHh7G8uXL226VN910U7CsEN7znve0/67X69htt92glMIxxxzT/nzq1KmjdKzX61hrrbUArP4VesWKFVi1ahV22223Dh1/85vfoK+vD+9973vbn9VqNXz4wx/u0GPFihX4/e9/j7e//e146qmn8Pjjj+Pxxx/H8uXLceCBB+Kee+7Bww8/7GxH3qdXX301gNW/RM+ePRtveMMb2m7FTz75JG699VanB0Mo73vf+zpCAfbZZx8MDw/jwQcfLFRvKDF9NXXqVNx222245557omTE2uDRRx/dtgfgpfHIbeaGG27AY489hg984AMd1x111FEYGBgI1mv33XfH5ZdfPur46le/GtW+svjVr36Fer2Of//3f+/4/GMf+xiUUvj1r38NYLWr88jICE488cR2v+botqS7+eZju88+++DZZ5/FnXfeGa3fP/7xD9x888046qijMG3atPbnu+yyC97whjfgV7/61agy5lq4zz77YPny5e01c+rUqQBWu6ePjIwE67JixQoopbD++usHl1l33XU73ga+3XbbYerUqdhhhx2w++67tz/P/9bXKL0vV65cieXLl2ObbbbB1KlTR61Re+yxR9urBgCmTZuGd73rXR26XH755XjyySexYMGC9px7/PHHUa/Xsfvuu1vDXXQ233xz/Pa3v8UHPvABzJs3D//xH/+BP//5z5g+fTo+9rGPBfeJjbxPJ/Jb0glZ0+EDNSGkcvIH5fzB2oXrwXvLLbf0ynjwwQdRq9VGXbvNNtsE67n55puP+mz99dfHE0880f7/yMgIvva1r2HbbbfFpEmTsOGGG2L69Om45ZZbglxbYzD1GRgYwNprr40NN9xw1Oe6jgDwox/9CLvssks7Nnf69Om49NJLO3R88MEHsemmm7bdK3PMPrv33nuhlMJnP/tZTJ8+veM46aSTAACPPfaYsx0bb7wxtt122/bD8zXXXIN99tkH++67Lx555BH87W9/w7XXXouRkZHCD9Rmn+WbWbN/qiKmr0499VQ8+eSTeMUrXoGdd94Zn/jEJzpiyl3E2qCvT/IvG7bddtuO6/r6+sQXBJpsuOGGOOCAA0Yds2bNCq6jTB588EHMmDFj1HqShxTk7b7vvvtQq9Ww4447ivXddtttOPTQQzEwMID+/n5Mnz69/QKrlLmfy99uu+1Gndthhx3w+OOP45lnnun43DeW73jHO7DXXnvhPe95DzbeeGMcfvjh+PnPfx78cK2EkBqTzTbbbNR7LAYGBkaFCORfyuhz8LnnnsOJJ57Yjm3PbfjJJ58ctUbZ1nDzs/xLqde97nWj5t1ll10mrk8upk2bhqOPPhp33XUX/v73v0eXz8n71JVeixAy/mEMNSGkcgYGBrDpppt6HxZuueUWvOxlLxsVZxb6ApiiuN46rG8yv/CFL+Czn/0s/u3f/g2nnXYapk2bhlqthuOOOy7qF6FUfUJ0/MlPfoKjjjoKb37zm/GJT3wCG220Eer1Ok4//XTcd9990Xrk7fr4xz+OAw880HqN74uLvffeG1dccQWee+453HjjjTjxxBOx0047YerUqbjmmmtwxx13YN1118WrX/3qaP10QvqnSmL6at9998V9992HhQsX4rLLLsP3v/99fO1rX8N3v/vdDu8Ek1gb7HWfTASefPJJ7Lfffujv78epp56KrbfeGmuvvTZuuukmfOpTnyp97rvwjeXkyZNx9dVX48orr8Sll16K3/zmN/jZz36G173udbjsssuc5adNm4Ysy6K+eHLVFWJvxx57LM455xwcd9xx2GOPPTAwMIAsy3D44Ycn9WVe5txzz8Umm2wy6nxqRoj8y4EVK1Zgs802S6oj71Pzi1BCyMSBD9SEkK5w8MEH43/+53/whz/8of2mbp1rrrkGDzzwAN7//vcn1T9z5kyMjIzg/vvv7/ilzfY24yJcdNFF2H///XH22Wd3fP7kk0+OmQ3TRRddhK222gq//OUvO34VyX8hzZk5cyauvPJKPPvssx2/Upt9lv9K2dfXhwMOOCBJp3322QfnnHMOLrjgAgwPD2PPPfdErVbD3nvv3X6g3nPPPb2plMb6rzyxfZX/Cnb00Ufj6aefxr777ouTTz5ZfKAu2wZnzpwJYPWvfK973evan69cuRL3338/XvWqV0XXmULZYztz5kz87ne/w1NPPdXxK3Xunp23e+utt8bIyAhuv/32DtdincWLF2P58uX45S9/2X75HwDcf//9o64NbUcu/6677hp17s4778SGG26IddZZJ6gunVqthte//vV4/etfj//+7//GF77wBZxwwgm48sornTbZaDSw9dZbW9tTBRdddBGOPPLIjgwFzz//PJ588smO62bOnGldw83P8jeTb7TRRslrlI3cTd3MTBHD/fffj1qthle84hVlqUUIGWPQ5ZsQ0hU+8YlPYPLkyXj/+9+P5cuXd5xbsWIFPvCBD2DKlCn4xCc+kVR//mvgmWee2fH5N7/5zTSFHdTr9VG/7F144YViDHG3yR9KdT2vv/56XHfddR3XHXjggVi5ciX+53/+p/3ZyMgIvv3tb3dct9FGG2Hu3Lk466yz8I9//GOUvJC0VLkr95e+9CXssssubTfQffbZB1dccQVuuOGGIHfvddZZZ9SmeywR01fmPFh33XWxzTbb4IUXXhBllG2Du+22G6ZPn47vfve7HemCfvjDH3a1r8se2ze96U0YHh7Gt771rY7Pv/a1ryHLMrzxjW8EALz5zW9GrVbDqaeeOurX0byfbXPqxRdfHLXe5O0IcQHfdNNNseuuu+JHP/pRR7tvvfVWXHbZZXjTm94U1lCNFStWjPos/5LAZ1d77LEHbrjhhmiZKdhs+Jvf/GZHCjJg9Rp13XXX4eabb25/tmLFCvz0pz8ddV1/fz++8IUvYOXKlaPk+dYo2/mHH34YP/jBD7DLLrtg00039TXJyY033ohXvvKVUe8jIISML/gLNSGkK2y77bb40Y9+hHe9613Yeeedccwxx2DLLbfEAw88gLPPPhuPP/44zj///KAcqDZmzZqFt771rTjjjDOwfPnydtqsu+++G0B5v34dfPDBOPXUU3H00Udjzz33xF//+lf89Kc/jYo1rZqDDz4Yv/zlL3HooYfioIMOwv3334/vfve72HHHHfH000+3r3vzm9+MOXPm4GMf+xjuvfdebL/99hgcHGxvyvU++/a3v429994bO++8M9773vdiq622wqOPPorrrrsOf//73715uLfZZhtssskmuOuuuzpeFLfvvvviU5/6FAAEPVDPmjUL3/nOd/C5z30O22yzDTbaaKOOX1XHAqF9teOOO2Lu3LmYNWsWpk2bhhtuuAEXXXQRPvKRj4j1l22DfX19+NznPof3v//9eN3rXod3vOMduP/++3HOOed01a5TxvaGG27A5z73uVGfz507F/PmzcP++++PE044AQ888ABe9apX4bLLLsPChQtx3HHHtdeabbbZBieccAJOO+007LPPPnjLW96CSZMmYenSpZgxYwZOP/107Lnnnlh//fVx5JFH4t///d+RZRnOPfdcq9v8rFmz8LOf/QzHH388Zs+ejXXXXRfz5s2z6v+Vr3wFb3zjG7HHHnvgmGOOaafNGhgYwMknnxzdh6eeeiquvvpqHHTQQZg5cyYee+wxnHnmmdhss82snkE6hxxyCM4991zcfffdlf+aevDBB+Pcc8/FwMAAdtxxR1x33XX43e9+hw022KDjuk9+8pP4yU9+gje84Q049thj22mzNt98c6xYsaK9RvX39+M73/kOjjjiCLzmNa/B4YcfjunTp+P//u//cOmll2KvvfYa9cWKKee+++7D61//esyYMQMPPPAAzjrrLDzzzDP4+te/3nHtgw8+iHPPPRcA2l9A5DY4c+ZMHHHEEe1rV65ciauuumrUyzIJIROM7r5UnBCypnPLLbeoBQsWqE033VT19fWpTTbZRC1YsKCdwkfHlq7FPKfzzDPPqA9/+MNq2rRpat1111VvfvOb1V133aUAdKSacqXNsqUwMtMkPf/88+pjH/uY2nTTTdXkyZPVXnvtpa677rqgdEo2pLRZZruPPPJItc4661h1fOUrX9n+/8jIiPrCF76gZs6cqSZNmqRe/epXq0suuUQdeeSRo9L5/POf/1TvfOc71XrrracGBgbUUUcdpa699loFQF1wwQUd1953333q3e9+t9pkk01UX1+fetnLXqYOPvhgddFFF4ltzDnssMMUAPWzn/2s/dmLL76opkyZotZaay313HPPdVxvG6dly5apgw46SK233nodKZ3ya5cuXdpRR96/V155ZZCOShVPm6VUWF997nOfU3PmzFFTp05VkydPVttvv736/Oc/r1588UVRv1AbtNmWpPOZZ56pttxySzVp0iS12267qauvvnpUnS5c88elR8zYuoCQouu0005TSq1Op/TRj35UzZgxQ/X19altt91WfeUrX+lIh5Xzgx/8QL361a9WkyZNUuuvv77ab7/91OWXX94+f+2116rXvva1avLkyWrGjBnqk5/8ZDsllG5fTz/9tHrnO9+ppk6dqgC0bcnV77/73e/UXnvtpSZPnqz6+/vVvHnz2inmclxrgtmPV1xxhTrkkEPUjBkz1FprraVmzJihFixYoO6++26xL5VS6oUXXlAbbrhhu+8k2eaak+OyAxgpzp544gl19NFHqw033FCtu+666sADD1R33nmnmjlzZkcKQKWU+vOf/6z22WcfNWnSJLXZZpup008/XX3jG99QANSyZcs6rr3yyivVgQceqAYGBtTaa6+ttt56a3XUUUepG264QWz7eeedp/bdd181ffp01Wg01IYbbqgOPfRQdeONN466Nrdn22Ha7K9//WsFQN1zzz2ifELI+CZTim8lIYRMXG6++Wa8+tWvxk9+8pNRqVaInYsvvhiHHnoo/vCHP2CvvfbqtTqEkC5x2mmn4ZxzzsE999zjfZ9BLznuuONw1lln4emnnx7Ter75zW9GlmX43//9316rQgipEMZQE0ImDM8999yoz8444wzUarWOFwmRlzD7bHh4GN/85jfR39+P17zmNT3SihDSCz760Y/i6aefxgUXXNBrVdqYa9Ty5ctx7rnnYu+99x7TD9N33HEHLrnkEpx22mm9VoUQUjGMoSaETBi+/OUv48Ybb8T++++PRqOBX//61/j1r3+N973vfaNyo5LVHHvssXjuueewxx574IUXXsAvf/lL/PGPf8QXvvCFrqUrI4SMDdZdd92knM1Vsscee2Du3LnYYYcd8Oijj+Lss8/G0NAQPvvZz/ZaNZEddtgBq1at6rUahJAuQJdvQsiE4fLLL8cpp5yC22+/HU8//TQ233xzHHHEETjhhBOS85BOdM477zz813/9F+699148//zz2GabbfDBD37Q+2IsQgjpBv/5n/+Jiy66CH//+9+RZRle85rX4KSTTio1PRYhhBSBD9SEEEIIIYQQQkgCjKEmhBBCCCGEEEIS6OkD9be//W1sscUWWHvttbH77rtjyZIlvVSHEEIIIYQQQggJpmcu3z/72c/w7ne/G9/97nex++6744wzzsCFF16Iu+66CxtttJFYdmRkBI888gjWW289ZFnWJY0JIYQQQgghhEx0lFJ46qmnMGPGDNRq8m/QPXug3n333TF79mx861vfArD6IfnlL385jj32WHz6058Wy/7973/nG3sJIYQQQgghhFTGQw89hM0220y8picu3y+++CJuvPHGjjc01mo1HHDAAbjuuutGXf/CCy9gaGiofZTxHcD5mlz92GqrrdqHr6yOWU9ouRh9syzrOELLwSgbIzOF2HJ5n13Q+rtbZYHiY9LNct2WWa/XcUHr3yK2pyPVU6/Xk2XqZVMYL2Oily0yJh/84AfbR7PZ7DhsdVbdP2ZbsizDBa3Pq5JZZrmUsr1Yu4r2bS9tVsJ1/41dg2JkuqiynWWWSyk7nuembY1xjVGv50k3y61pMs21IsQmytY1ZG1Yk8akqvXSVm/s/SQvt95663nL9SSPzOOPP47h4WFsvPHGHZ9vvPHGuPPOO0ddf/rpp+OUU04pVYcprX/NwQvZ2EyxfBZiBLZyoUwJkKF/0ZBfO0WpUUYa+oWET1+XPrlMl26uekLaaLvxhZa1lmvpauoX0l+xdpDXk2IHur4ppMqcErDI+fpHLyvV026jQ2aQDWUZkNBHRcckRldTpmRrrnpt9m6b/7ZyADBp0qT2uf7+fqdMs1wRO5Cw1WvrV5/MmHkitTOG1Llprl2xa3QZNhv75XQ372ExMp33ooBrU2W68M1NqRwQdu+xlUshVqa05vnKmjJDKWKzPn11pP2T6zoXvZybSfdNyzVF5knoPqiq9cBF7D6xyH1BKlfFPrEXc7NoubxsVXPMVm/ImNjKhdjNuHjL92c+85mOX1AeeuihXqtECCGEEEIIIWQNpye/UG+44Yao1+t49NFHOz5/9NFHsckmm4y6ftKkSR2/qOS4fjkzf2VetWqVUxfzm5C//e1vou4uhoeHg69N+SU1GxnByMhIcLm8D7LhYdRqtaBvKXNCvxk1+1nvA6UU6vW69ZxJ3i7V+tusV2+3qZtUNqa/UvvAJOXb85Byqfq0ZVi+9fa1edWqVVCQ50+sTOe1mpwUmXpZSQZg90LJhodRr9dH2YykexVjEiMjxr7zuZi385JLLmmfO+OMM4LridEvBltb8jmd8ku8DfPaWbNmtf++6aabVl9jWX/MOqX1KYZ8TVSIu3/EYLbZXC9Dad9PWv2TtLYq5S1n+5XANiZAp/4x+nTjtTGpNlGEInYZ2iep9uMjVXd9jwGE7TNypH1YVe2U0MegiI2WtV6meO2F1BN6ziR1X2HKiVlrG43Vj0jZ8DAa9bq4L4lZu8oaax3zHh+zh9LLFkFvq8/bLmb9DvXicz0fxJJ6P+7JL9RrrbUWZs2ahSuuuKL92cjICK644grssccevVCJEEIIIYQQQgiJoie/UAPA8ccfjyOPPBK77bYb5syZgzPOOAPPPPMMjj766F6pRAghhBBCCCGEBNOzB+p3vOMd+Oc//4kTTzwRy5Ytw6677orf/OY3o15UJqGUsrpLSK49uit0vV4f9dO+6ULkIsZFyeeqotcluej5ZObuKUCnC6zPfUFy3ZbwXRfqbtF2j2n1T6qrWrcywOluQCkvwCpKjO2Z/ZPqtmXK1Osx7SBmTFLd8l1zKLO5DgtuQPm5om63qS5wVdmsuY6Y7sX33ntvUr1VhI7EEvJiOyj/y4RmzZqFBx7YBY88sh123PH32HDDP2LaX/+KfXfeGVdddZWznPT/lJfs2MqGvpzOh7OegP6xue+pANnmPVSfb761y1Z3LjPGdbQsF8ay6EZ4z1iYm6mE6J7vD1Ldd2NkunSILdcNYlyhi6DPXV+/S2ui7g5tEhMOWQVOt+SAcBVp7ZKuTdnX2/SN0dVE3x/EYNqeLjcmHMNH6n0zVUZqnT17oAaAj3zkI/jIRz7SSxUIIYSsgTzwwC747W8/hCwbhlKvx047nQDgr71WixBCCCHjjHHxlm9CCCGkTB55ZLvWw3QdwDCefHLXXqtECCGEkHEIH6gJIYSsccyYcReUqiPLhgHUMXXqzb1WiRBCCCHjkJ66fFeFmWLrhRdeaP9txhJK8cNS3FFMCoaYmMkicQZ6fIUZ2yDFv0jxFlIchC8uq4pUHL64DEmm9Er/mDgJKUVTanyzSRHbs8Xn5OkbouPGAuLaY2JlykrF4YrTDEmbJfWPpG9qzJ1Up3mtT4YUK65jjpfUTrMvV65c6az3rLPO6vj/6aef3v77gQcesNbrel+Fzoknntj++7e//S0AYP277sLu222H66+/3lkuBrPdl19+LLLsMii1H4Arceuti7AcwOLFizuui4nrKyuGq8x6XfWkvt+gyD3MZZc+/WwypXlTVn+lxrUXiVlOTf0YYz8xadC6kQ7Il5oulSrmjUlZafQkQt5LkKdINedfWTGmoTZiynHJDHkvkIvYdoTeNyVdy1zbY+a4dV9vqVd/z4Uv/axJaP+YOkjjXFUqSJMq5lvqWE/IB2pCCCHER5YtQpYt6kneYEIIIYRMDOjyTQghhBBCCCGEJDAhf6HWXbwBh6tvQIqBIi5LNvkut9sQd9pseLhQOim9rM8dTXcXL9I/oe5yMfUUcSOxukkFpDJzulgr1ZHSABid1iAUyfWxyLUx7vQmbReigBQ7EtJY9/X1tf9+8cUXg/QBitmBbWxT+ieG1HnkctuKdUiS2hnT7h/96Ecd/7///vvbf/tSdelui+b43XPPPe2/b7zxRgDAk8PD7b9TiHEDltzTfe6o+npQFkXcSIPW3cgUOzEuwhLdSqUizZOy7utlrYFl9W0M0nog3V/McmW5Zrv069Cj9XlZqR/LmlPdcOePSY0pnS9CWWnZ9DRoZdl6aPihz83c3M/l51z7RBe+MalijhdJnxazr0i1p26ERvQ6PeCEfKAmhBAy1pkHYH8AV/ZaEUIIIYSQZOjyTQghpMvMAzAI4FgAg/j731/TY30IIYQQQtLIVLd/Ey+BoaEhDAwM4HwAUwKu150A8sbOAbAkUX5s2Vz+bABLEeZWYSubom/Rdi41PgvRPVXmWBoTm83YZC5NcDGx6Wq+R1iUGXitT2YIIeVcuoeUrWn9N9Lqu6rtoNfrQUy5In2bKlMqN2399Ts+33vvvdt/Dy5aJJbV2/I/+G9cimMxggZqWIXD1/kBjp96KgDgkUceAQDMVgpLI13XTJmhxKzR3RiTkPVgLK2XoTK7uXYVKTue+rZsXWNsL/S+5ZMZwkTYy4TuK3oxN4u0M8YOxvKedlRGh9a9Z6zMzfEsc6ztZUJ5FsACAM1mE/39/fLFahzSbDYVWm+yz496vd4+zHNZlrWPvr4+1dfXpxa1/o6pJz8WOj53Hbnsha2/Q67Nj1yXwQA5tVqtfZi6mvXqh6uewchyuq5S/5n6+Pq1rDFx9atPV0mmrlu9Xvf2UYr9+MqaOqTK1O0nt6GydY0pJ9meq58XWspJssqyg26W66ZMfS2o1Wrq6KOP7jieeeaZ9mGzH5fMLDtEAUoBK1v/ztPOha+Xkr5l9U+oPdnWgxiZtr4bK/Zj2kHMHIuR+dGPflTNn/999epXL27bROralZf9zW9+o0466UZ16KH3q5NOujFqjY5po263IdeF3P+K3E9C7/GmvVV1Dwvtn17ZuzQmqXNastOy2xnbxpC9V8hY2u7HvW5nN2Saa05qv/rGRNr32PaerjGRdNdlhj4f+O7xMX1b1f3EVm/Ic4ZNl2az6X02ZQw1IYSQrpJliwC8GUrthyy7CkrZf90maxb33fdKDA4egywbBrAfgPkAitnGdddNxymnvAa12gj+93+3ADCvZX+EEEJIOTCGmhBCSNfJskWo1T7OhxvS5qGHtkGWDUOpOoBVAOYWrvOWW6ahVhvByEgNtdpIKXUSQgghOnygJoQQQkjPefnL74VS9dYv1A0AiwvXucsuK9oP0yMjtVLqJIQQQnQmjMt3aD7LlStXAgBGWn9njtypVSLlY1PGC3j0XK6mrua15v9Dz5noOeliypl5ZyX0ejNP/ryyxkTv9xhdpfHqhr0AnXlyTSQdfH2rI+UFNG3P1pchZWPsSbrWmf/UkzsdgDUfcm4HZjtD9THLmf+35oFPyBfZbcy8s/fccw+WL98LzeZrMDBwE6ZMeem1kL526H0i2Vo7L+/wMGq1WtQc02XEjImE2S5XvdnISGl5lWN0ryq/p228FOLr19cu3z1s/fWvwf77P4VHH90et99+JiR3b73d0rw95ZRZAOZhZGQugMWo138F/bcEXQcpJ3PSPc1yrqw10MTXtzrSeJa1Hklj4rs2dO332aKe49tHWffG1HpMpHam5rMua2x99qx/5sxrHqBL6t5BWhNT7/G+a1P71lcudV9vntNzbK9atSpZH2kvI93jy1oT9Tldq9Wi6smyrNLnjAnzQE0IIaRali/fC3fc8UUAq/DII2/H4CAwf36vtSITic03vxmbb34zbr+9zFCARXjp4bwuXUgIIYREQ5dvQgghQTSbr8Hq2NYGgFVYvLi3+hBCCCGE9JoJ8wu17sYZ48JUlguM0wUVo126q3LxDHWTKuKqkuqCY2Jzuw2pM8a9UXLnz91fsuFhNOr1KHcP3eXE5+6V2l8u3W01hIYQqJari0ufmL6N6a8q7N3lApcp5W2HrrvpPpTqLmu28dJLL8Wf/rQRbrllGnbZZQVOPXW30TJbLs1SPTH6lOXKJvHIIz8F8HbkD9Vf+9p8fO1rYb8khuoQ48Jl9p8+T4qsc6kulSYx7qDR60NrPpfl4q27BAKyW2AM0piY/fOjH/0ouN7UdseEyOjX+lyYQ+02xiYkiqxduht+3XP/s4VR2NwtAbkP9DXaJGTvEtJOV2hE7H0zRr+q9nOSPqm277ThgPumdQ+ZEEoWEwoQ2re++6h0rtfPDkWwhZlkAS7NMW74MftLCWc9kf0YE37k0sncC0vXxjBhHqgJIWSs8Kc/bYRTT52FWm0EF1+8JYB5KJr+ZyyQZYug1CFY/abkxZgIbSKEEEIIKQIfqAkhpGTMVD2rX4g0MR4+V6e5Wt2WMfAlPSGEEEJIT2EMNSGElAxT9RBCCCGErBlMmF+ou5G+SI+vMpHiTcrC5+MvvRa/rDi7GKS47dRUOM7YWUt8ldRfef+o1t9m/KCun6vvxsqPc2WlzUhN6VFW+ojUuD4gLq7GlTZrxBITr+OKvbKlA1odM/1Sqh7912kpVVeROJ6guM2A9BZSOV/cvU7qmtOu0xLXZ9ZrypDSy4XIDInTdNl70fUgZU6V+c6JIjHTkg1L982y3jnh1CeyjpiYwJi0ftJ9KTWNXsyaJ72TI+V9GHk8fMz4SfHMEjHtNPu9HVc6PDzKFlLfTxFjlwceeGDH/y+77LKkemJITU+UGo/q06Gs/YFEsP1bZFeRlrUtNyHuPzV1lz43bXuZst5vEBpL73q/SQqh7/7Zfvvt8dRT++OZZ+ZgnXWWYIMNru249i9/+Utb1xgZoUyYB2pCCBlb6Kl6CCGEEEJIFTz11P546KFvAViFFSvejUbjOAwMXNU1+ZkaC6+qi2RoaAgDAwM4H8CUxDrmAFhSYVn9+4+8gyuXafmGpWqZUjlbH5QtL5cxG8DSQDk2mSnfEhbtnxS6LdNVLmRsY2UWHctQmWXNTV3f8WYHZc1N6X2tqX2bz8XZSmFp623WtnqtZVv/xo5Jt2xPKlfFemmOT9F70Xhau3opc6nxWVX3vyLlJqLMUeuRtpb04r650fTpHZ8/9s9/Vi4zBcosXs52L+zl/SSGmPtm6P7Jde8xKfO++aO+b+J/V34AI2ighlV461rfxYfXPqF9vjk0FC3vWQALADSbTfT398sXq3FIs9lUaHkd5Ue9Xm8fWZZ1HPp1+WcLW3+b9ehHrVbrOPLPF1qulWRK5UKPhYEyXO20tcOne6zMvP7B1t8pbZT6PaSdoboWGRO9nTHlGo2GajQaajDLVKPRiNbVpa9u+6b9S33rk+XqV18/x8wxSdeQa1PGU+8Dc0xibSHFhmLmiTQ3pXb5dO3GPClatmqZeh/EzM2Y+0Iv+kfXLcZ+pDlu2my31toy7CB0vQpZg0JlmmtyiB3a1stu7CtcfWCzp7w9g602SteW1T+mrrHlXHaQ2rcx5R588MGOI9XepT1RzP22yJhUMU+KrCO+8SxjTxszT2xyXWMSYsNlr5e29dw2r8uS6etnSaZki1Lf7rbbqQpQKstWKUCpnXc+Qe2///7tQ9fV7ANbf9Tr9fZ8azab3mdTunwTQgghhBBSMpdfPhnXXTcJe+zxQq9VIWRCs8kmS7Dbbqdh+fKdscEGf8V66/2xq/L5QE0IIYQQQkiJXH75ZLznPdNRryucfXY/gHngezUIqY5NNlmCTTZZ7dT9zDPdlc20WYQQQgghhJTIdddNQr2uMDycYbXn6txeq0QIqYgJ8wu1/kr2LDD1jVKqI4WOVCfQmVpFqrcI5qvmlfZaelOGlOop74MsIBWHs78sMiVdpfQWUhqRzEgbkpoGqqwx8JGa/qOdqkQpDA8Pd/RJkZQCqSnIfOT9aZsnkkxpTEz5Vn0cNhtkwwE2YNXPYev6GJWVes6cJ5KMGJvWr/WlS9KvDbKJgHXEJ9OWrsyGuR5UNa/1es25KcnsdQpCoKV7wDxJtR/nNa3rpGtj1oqySL2Hrb5k9LwJSXcjUeQelgWmb4lJM+gbk1B7z3XL1y6z3633dYuMpHuWJd2Nr135HimzzOmYe6GOWY80N88++18BDAJYheHhBlanUCwu03WuyFpZZEwkO6iKmLbq+krjVyR1mOuc7fPUPZuUiipmPZBSwUrz1tSn/ZzRWi9jbFHaR6fuLy+55BJRpk1+jt6uVPudMA/UhBBCCCGEjA0WAZiP1b9MLwbdvQmZuPCBmhBCCCGEkNJZBD5IEzLxYQw1IYQQQgghhBCSwIT8hdr0q+/r62v/vXLlyo5zkq++Ga8QE3Ojl9XjNH0xga7Y48xSJiRGMSTmzaxHjzuSYlLN/pDiz1wyAGDVqlXtv5VS7jhyC92Im5bi83xxo7Z68rj20Lj/1aLS2mnGOsXE7tRqtfZY+q7TkexdirXSY4Bs8YupdmDG2en1SvGL5rVVYeuDnJjxKit21hVTZpub0hwvYnvWehz66phrkEtXE6nvfPXExO+nIsV7xfRPKjG2VVXMtNTOstosvQekrH721RNar36P9/V5kTFxxXTHxKabFHknh37t0Ucf3XHtOeecY63XpkvM+OlrgDl+Lt279U6XInH/qe8eMT/37RG88j0ybKTGPndjvSyT0HcP+NaD0HbGzOsifdnrfq/CDvgLNSGEEEIIIYQQkgAfqAkhhBBCCCGEkAQmpMu3ie5SHIP0anmfy5KzrCUFUUiqCZtM00XB1U6fK4PprpPXYysVkurJllIjVFdrfSW5hkhpe8x+113SzTABiZCUbQqj21RWSg+zbIyLnuS2lZKCIZcp2YF+zueyFJpOxsSV/g4Y7eLZ65Q/RVKgxaTNkvpSGs+qUtrZbC8PjYjRXacsl91uuRNKLozO+0KFbnNS2JJEUjqbgLJBafMs18boK6VsK9LXqWtXqgyfHKmdUmrDsnT3rXOhMr/1rW/h0kvruOqqGvbbbwRXXXVVx/kHHnhgdX0Beksye+2eGrLO2cIUitQrERPOI4WEFVmjywrHilm/Q/cyZdpLFfXGrJeptjcWXOtjwoTK6Oc14oGaEEIIIYRMHC69tI63v30S6nWFb387w8Ybvx7rrHNFr9UihKyBZKrXX70lMDQ0hIGBAZwPYEpiHXMALClQdqnxWUgn5jLN78v1sq5zNpkmNh1C2inJNMtmlutSZErlpP7xlZWw6e4qV9OTvDumSFE7SKFo30rYfseZjdVtTFkkqtS1SFnJDqqyvTLLhZSNmdNlyCtatizby+uZHSDTRi/nZsjaWoa80LIx62VZMssst6bIXJPt4Iot/hfffnAehlUd9WwYb66fiQ+s9en2+eeefRZAuetByD1irPTPWJA53u5FY6EcZY6dcs8CWACg2Wyiv79fvliNQ5rNpkLLczbkyLKsfeSfLYwobx4LAVWv1zuO0HKwlNX1q9VqHUf+uU2mea0kUzpc9djK+uTp5Wz9HtI/Ie1KaadtvGy6Zlmm+vr62ock0zVe0rGwJS/UZmPtNrWc2ZZaraYGW5+nzhNbW1yHT9cQe4ptp29ulmV7Zc6TvKyr/6Q5VHRuFmlnWbYn6a6Xlcq52l20nSEyXDKlNc9WbzfHxFy7QuZxiMyyxkRaS2L0jVmjY+ygrLVLKhdje1I7zXpC9wZl2l7ofeHnP39eAUrV6yMKUGrjjd+rttpqq/YhrQcxMqU9WpljWYYddKNszDyR9rTSGPRijfbtSSTdUvddvjGp4l4ds16myuzWuhfbztT9ZbPZ9D6bTkiXbyl+sEiKAZ0iMUBSOiDzWqlcDJI+kszMiEEIifcOqVeiqnZadbfEkAFy3LRuQzFxI3oKtKr6zlf2Rz/6EW66aTPccccmuOyyTwNY5Lx2ZGQEqvVvTAqiGH2kuPaYevTx9CHFqnYjTZaJZLMSMWuFz95D9akqxtyVOsycJ6ZOrvXJ1roicyoUnwxbe/IxCUm5Z5PjW0tSkd4DIlFE1yrmgnQPk+pRnvc/SGtiN2xNTzNYr9cLpdiT1kTr+AWsIyYxa3Rovb/4xZHYYYe34x//2BWbbnoz7rjjf+z1wf9eCV1mnmq1tmoV+hqNjv1AUpsTyobWW5U+UvpSaZ6YZWP2NqltKWut6Ma89WHOsVRCnoNyYtaO0D3bWOjLGFz3qZh2TMgHakKInZtu2gxf//rrUKuNABgEMB/SQzUhhBAyFnn44Vm44463IMuG8eSTWwGYB97PCCG9gGmzCFmDuOOOTVCrjWBkpAZgFYC5PdaIEEIIieexx16JLBuGUnVk2TB4PyOE9Ao+UBOyBrHDDsswMlJr/ULdALC4xxoRQggh8Wy00W3th2ml6uD9jBDSKyaMy7fu1x+SR1V5rrOR5ybOhodRj4gpNWMiQuJsR9Vh5HU2y/mIiRuRYp2kmA4pvqpIDG4Moe2UYn6AcBvyybfFEqnW32XFQcaU/frXXw9gHkZG5mL15uMl97jQ2MIy0WNwirzfQLI1s3/0HOgxMovED1cRtx0TIxUT31nVexxCMfORS/Yds3alYo67750YEq6+9Y2JqUO343VNpPtAjD5VzSkd81yMzJi5oK8lEs6+i4xLNudJEUJjNUPf91Im0v7pD3/4JIBroNRcmPczk5h5msdMj7T+jrH3LMucYxmUaz7ADlL7Pma9jOkvc07p99giccASvY5HN4l5j0Po2BbRRxo/c704/PDD8fDDs3DBTQPYc9cVmDHjxva5Cy+8UCxbBVW9eyBURqq8CfNATQgJZREYZ0YIIWT8w/sZIUV4+OFZuOaaj6OOVRi+toG99vpSx0M1CYMu34QQQgghhBCyhvHoozsiy4YxjAaybBiPPfbKXqs0Lpkwv1CnuiFI7nymy0Tbxcpw1zXLAW43EpsrgX6ty43Mdq6qFDaprg+Sa09Mu6R6q3Izk3TIU2jktN2ZAtJfucbWl5JFoqrUM5I9paTbiHXdLhKOYavHpx+gpZ5RCvV6PcpNKlUnybUv1TVMkgeMHhNdjtSuImlynHWhvHCVIteG0g0XN8Ad7gPIafxikFKyFFmDXGnPgM7+M2WUNackyrpPhqZd8vViVWl7urFGF6GMlEi2vZerXKxMiZQ1yFYmNO1oajqyLMvaoYk5+tpRVf/oLt6mnCJhOWXt/SSZYyGdYrcx17K9916Ju++ur/6FWjVwzz3fwz33LLJeq5P3a0rqPn1MqnqWqcKtW4K/UBNCCCGEEELIGsZOO/0N//ZvC/HuDX4KplJNhw/UhBBCCCGEELIGstNOf8MJm3wFfJhOhw/UhBBCCCGEEEJIAhMmhtqWnshGWTFcZabi0Mu6UrLYWtSt2L5QUuMT9HRkDUscaxXxXTG6xsQvmvEmVYxRkbRHEpKuMWOQGgsdE9dXViyYLz2KXq8ZS58a1yrZnpRmBSgvXVKoXZq6Fkl/N9bSnIw1Utc502ald3KkrtHtdw0ExMqZ5/R53Y10KECnvs70RJE6FLkPhaSbtK17Rd6pIL2nRErhOBZI1UdKSVYEfe2X4oWBcDsp670p5t/SfUnan/jWdts+NbdZ6T5WVbpXXR/f/Uyvx4wxN8dTp8x3iIwlzLE9/vjjAQBbwz9etj5wpbiMrcdF6j2/G++G0OEv1IQQQgghhBBCSAKZGodfuQwNDWFgYADnA5jS+kz/XiSkQXMALEmUbytrfi9j08ElU0p7n9eTqm/Z7SyrXEebW98+zVYKS7Ns1LfJVY7nWLKDVJljsVxK2bzvZgNYirBxT5FpWytCytXMXyJadtq1eYL09aBo3+byQuzbVTaW8TRPeiEz5H7iGp9u2o9etlv90wuZqWXLmpuueiHUOdHmSVnrpSlTX/tHjP2JTeZ47J+ljnOuskD192qpXOyePy+7NOEX84k2T8aaTJ/tlSkzttyzABYAaDab6O/vly9W45Bms6nQ8lbKj3q93j7Mc1mWtY/8s4XGNbZr9Tr1el1lXUetVlO1Wk0Ntv7WZeg6ScdCrR7X4SoHo6zU5izLOvSNaacpM6WNvjFxjftg62+p/lQ7iNU3pX9ctmbqY5Mp2ZNeLnQcYsfE1F2yd0lWzFhK+qbOrxR5edmQuZgiU1qDJJnmOckOzP6KmSep9h4yRnk539woczxt5XzydbstS6Z52Ma6jDHxybC1sV6vR80xae1yXVvU9mLuYZJM233RN8fLXINi7vExh7kepOoaM6dj7ECSKfWHq7/KXA+KlKtiX1H0Hl+G7YWsHUX30UXLhZTthf38y7/8S8ex+vN5ah7+WwHzkmW69mW+tauIHdjssup9tCTTpoNr7XLVk3/WbDa9z6Z0+SaEEEIIIYSQnjIPwCAuxbEABlv/J+MBPlATQgghhBBCSE/ZH8AqjKABYBWAub1VhwTDB2pCCCGEEEII6SlXAmighlVYnYhpcW/VIcFMmLRZMWmqdKRXxMekPDJTDuj1+NIIhb7+32yH+X+pHun18WY90qvvJbKIFANSSo+YFGT5OeW5brVabn0kYlIFpaYViknt4pOROVIMpLbfhs2+R10TIDNVV+d8K5gCJialhlV+AOY8kUhNZSatFUopca0oPP8DdJDKmtd1I/WFNCa+dUVfg3x9kEroWgrE9ZfU79LclNoZ0weptuZDSjdpYtXdcg/z3SdT11pJprS253+HpBk0SV0PfO2Szpc1F2LSKZZFTB+EYt5r8naljGco0n3TpKr9paRPWW2OWYP0djnnW4Vpsy677LJRMpU6BAdjPwziKgCLkupNeX7JLP1v9om0d9cJ3cPZZKbeQ2LGp4q1asI8UBNCCCGEEELIeCXLFuEYNYhFWVY0hTrpInT5JoQQQgghhBBCEuADNSGEEEIIIYQQksAa4fKt+/zrMSOxMRF5rEUWEJsg+fVLMcLmubysLc5AkinFfhSJM5LaJcWQme2SYi+KxHCFxgRqF1ntIDUeLjSeebQa4fEmvjgjvS7dZuv1elRcjU5MTIvUd1LMlH4uyzJRZlVxtaEx0yYxc9xXtgx8dZalT+j7H3x0I/ZSsr12PGprPXDZpVnOJMbey6JInba1Ikcfz/w613tAXHXGyAeAvr6+UfJTYkpj3lPgWq98scVVvJMj5V6Tj4l0jy0r9tns16reGaATcw8r8t6bsuKAlVLOfYV+rXmvyfvS9u6RsvrZ964W6Zzet/p+pFarifsnKS7ZJOa+mRo7G/uODJeMbrwvo8h+N+bamHdOhK7D+loOACtXrnReW+Q+GfNsk/pep1D4CzUhhBBCCCGEEJIAH6gJIYQQQgghhJAE1giXb8mlKwY9PYokA5BdD770pS91/P/Tn/50+2+Xy6nCaLcI01XFWTYifY1+3tfOGJcXya3GdOmKSZuT6toX8nkKIe78eTttLqcunWJccmzy87RiVaQYiCHERhT8bljOsbbUH+NOVFY6IFN/lztRbMo6/XrTpUqv15Qf4zYpubn61iDbtVWmgXH1gS0sR5IvpTYs4k5YVptjUk+lztUioTah+vh0tbkFulya9bpc7rNZgfsCIIdjpYY4FEnNI50rYrdSiIO0f4qRIaXJkSjrHmbSjXR8JqGhNikpB1NsPcaebOfyuRkTRii1M9XVN+ZcWaTYfk7M3i9Vh7LCjUJSuNru8eZa7gpnLZMidZahD3+hJoQQQgghhBBCEshUN77KKZmhoSEMDAzgfABTEuuYA2BJhWX173TyDs7LvXLHHTuuvf2OO1661jEccwAsNT4LGbiq21lGubyvZmN0G4Fq21l2/5jf0yrLubydKROv2+0cD/bjKyuNSVUyTaT1IFXmDcI3x2YbY2xP0jWkL1Nk2gjpn5qjD2YHlE2VWXbZsTJPxrrMUb+BSS+gbP3ruqfohK4HobY/3u2gqvVSH5Ox0M6yytn6q5u6jsd9xZoiM+W+OZ5kpu4rdGxr9Fja8z8LYAGAZrOJ/v5++WI1Dmk2mwqtlyGGHFmWtY/8s4UR5c3DVlaXkWWZqtVq7cMs99WvfrXjaDQa7UOSWa/XO45UXYu0U2pzqsy8PYOtv/W+0/tP0mGhoE83+0caI7Odpr4huqfqm5eron9i7CCknSkydTswrw2xJ1v/mPoVsXdpPQhpl01mX19fxyGtDabtSbra6lloaYdvbubXDLb+LmN+mYerDwYjZRW12bxsN9egEJstIjPV1iWbLaKrubZK903T9qQjtH9C77+x42new3ptB2b/lLV/0sekLHuPLZsqM6Rden+ljmWKrqat93pfEWN7vdiz9WKNltacsvbRMTJj2in1V8w93lw/pTW6G2MitdN2vtlsep9Nx3UMda1Wa/v367EpqT7/RVDGN+Rm/ILOxz/+cec5SXcz/qbR6Bw+vS1mu6RXwqfGhpnxiy+++KKzXikWMyZ21kQJ8TgxdmBea0sRYdZri9MMSemR0s5UuhHHavZ7WdfG2LeEaacvvPBCcFkdp30FxK6F6hvTP6YNpca8mTIl24yJP5fikiVibNaVikNZ9JH6VpJZxL5TdADk9ds877O9UPlFrg0t56vTTJ0HhMX9u/on1vbMOS3df02ktJrSfkCyGam/JF1duuXEzHFr2lEHkg3nZRWKxXem2mVVuHQvqqc0r137J1s881jrLx3f2lXF3j11vvmQ9rsxKdmkeV0kHWdoWqiqUj26dI1do030PinyHoky5gljqAkhhBBCCCGEkAT4QE0IIYQQQgghhCQwrl2+U1xtUl3BgPS0DzFpocxzkhuZ6UIR0m4bksuJlKrEdPE2XVVC3cpyl9zaqlXoazRGpUCR2pW7BWfDw2jU6x1lY9zwnalMLPXoNhTjXhXjolcWMa6+UlvKciOLccN3pYHTr82R7Ntpp7rM1tw0CQ0l8fVlFcSMQdt9tmV7vXb9l/ClZLHZTI4UjhEjsyxi+iTEZT/2XFVIrodlrSMxITJVhG4pI5TDN5ZSWs0qUvWZf0vproqEGMX0beg+oywXz26FTpXlFhyDZAe2kLQQV+iy0jfFhDtJSPsu17Uhe5mq3JYlYsZE0l3aV0ipDdv3vpZM6TlDImW+h9w3zbGV9l6S67a0j+51eAN/oSaEEEIIIYQQQhLgAzUhhBBCCCGEEJIAH6gJIYQQQgghhJAExnUMdb1eb/vTS/GWOjHxJq6YkhAvfVtsjysWLDReNwapnWY6IqnvYmKUUuPP8tQ3I7CnwZHianLdFfw2YBvrlNgPPYbDFfOeo/dfaoqvWELjpKXYHaA1vxwpa2JiykLTNcTE4zhjkiy6hKSiy+emZGtlxedIMUAxsV8xNlNVjHCqPlJZn13qSCkAfXF11notMYHdisvqRmxoWe9xiEnXIsVbpr4fo6NeSz36/a/IeKb2T8w8Tr1vlrGXCcG6JjpiZ0tfIy11psb9mpQVZyvpYO4HYuLIQ9eDmLU9KC464NqYuNWyxigmJZLUD9IerSyb8I1JzP4p9Fr9+URZ9qZBMgLK6M8Poc9dun45eh9J+0upnth2SoTuU8U6StGEEEIIIYQQQghZw+ADNSGEEEIIIYQQkgAfqAkhhBBCCCGEkATGdQx1aJyZLVeb+bftsyK++bo/fruegLg1KYbDlifXda0Zw6GXlWLROvS1oNdjlovJHy0Rk3e2G/GNRXLJSnEZUixKWX1gxi/GxIYMDw+341ukuCMfofFMMXXGxK2lxucA4bnLy4q7LZLztYwYICB9DSwyF8taK2LeORGa77fI2MbMGymXs6udAPDzn/8cN9ywKW69dSPstNNj+PKX93HK6HXOzpgYT9/7MUL1N+dwN3IXx8w/Ka5dsp+yYmerosicCo3fLaJPzBjF6JNlWXssTVuT7icmVdip896nVKF7Ruh90keMHaQi7Qe6ka/alFPWXCiSDzxmbuprcb4+5e/a0dsV+m6dzPa+qZLmeMycd41JjC7j+oGaEEIIWZO54YZN8eUv741abQS/+tUrAMwDsKjXahFCCCFrDJnqxVeXBRkaGsLAwADOBzAlsmz+vcNsAEsR//ZsAJgDYEmgHGgyYsuZZZd6ytraksu06ePDpm+Hfo5vskLaGSrPROqfqmQWKSvZQcq3YDY7CClZtH9c/V5UZuo8kWSW2T/Sd75jzfZC5vhY0bUXMkNseKzKtNWTl1u00U9xzmNvxzAaqGMVDsI3cAw+Fq1rCOPFDsz7vE6V62WRsmPFZqsst6bIDLmf9GKNrmr/FHKfdJVNlZnCWLGDiSKzyPOUXrab9h7bxmcBLADQbDbR398vX6zGIc1mU7X6pn1kWdY+zHO1Wq195NcsbJUxr3XVmWWZajQaqtFoqEFPOdexMOCaXEZ+xJSVZNbr9fYh9U+tVusoa/ZBWe209XMuz6WPbUzyawZb7QjV1SyX2remPlJ/mTKlMXHVY+vbGJkx9p5qd6l9G1POtBHdhkLtTT9c64FkT2ZZ6dDHOqacZHvSPClrbprl+vr6Oo5QXX312+ZCSLkYOwjp21hdY/WtYkyAeQpQCljZ+nee1/ZD7n+pth7TTnP89CPv38FWn/vkutbLquaJZAdSu8oaE996abtP2u7xMTZXZP/Uq3lShkxp/Gx9m5crsn8K3R9Ie6Aie7ay1ssYma71vMgeqCo7qKp/pDkWspYVHRNpDMy9TFV20I1y5vrtG8tms+l9NqXLNyGEEDJuWQRgPoC5ABaD7t6EEEJId+EDNSGEEDKuWQQ+SBNCCCG9gWmzCCGEEEIIIYSQBCbML9RKeKmT61XpUhnbeT2NRwzmq+Wl1/bb0oPkSCm1fEgpGKR6pD4qkkrJJUMplZSmSsHfH3o/t/tSKdRqteR0CT5dM0tKhhBdY/ogxPZtMs3xM+uJ0UGSmQkvX9N1SBn3nHYKhtZ4StfqmLZnIunuK6vjmhvK0LdI2iydImuF1OaVK1c65aTaCyCvHdI6E2OzqfoV6Uuprm6laNExbTYLTCHnK1dk7HVsfaKwesxNmba11YapW4zu0niFpmAB/CkvU/DdT8oaE1edvvqrSlcmrU+p9fjqirGvWq2GbGQEtVotSr/2PaxVVuov2zi47CB0jsecK0KmpYkzMfWXdNcpMscle9J1zSLSjprlqlwfy8Z3T+3FfasKpOew1DWGv1ATQgghhBBCCCEJ8IGaEEIIIYQQQghJYMK4fJflBqRjuiy1ZRV0eUh1l/O5tUgucHpbzHKprlhFXLh0F7iYemzuVcBLblKhrlm5TKUUhoeHS3XrdMmMcQNKdVmKkWn2u8veiyLpbhv7EJd4E939sYg+rnp9+FzTUt0JJcqy2VC3Ohu6TNd6FDI39bJ6iEyjXhfDYCQXvbLwucDFyAwdI3NsywrHkCgrzMQkxsUzRmbqfTMGaW4ErbstpHtce55Euoeaa7tJjHt26P4p5h4Wc1+PuYelEnNPNcP0dMx22ewyxP3a5Uobcv+bP39+++/BwUHx2lB7Mtccqb9iXLOLrF2pukv912h0PvaE3l/MUJdQd/nY9adIWQm93VKbfUhzMzQMx6Ss8FEfWZYFrV3J4WGpihFCCCGEEEIIIWsyfKAmhBBCCCGEEEIS4AM1IYQQQgghhBCSAGOoBaQ4ZEm+qUM7Xhf22AAp9Yweh2gSku7DFr8YE4cUEycmxXib51Ljq3xxR6F20O6fVvx0VTEbOlXFxqTG8vjijur1ujPVm0RVKSN0TN318fTFdyXFf0aWK6vNUlxyTNoeaUyk9cAXzxySViw2TZyennDVqlViPPFYiC3uhsyqUn7p9UrXmvZjxryFpHvMAtaQoBQ2jvMuktIDttqpr3sx982U9zTk8yQ01rHM+0lq+rRuYMqU9mFlxUWae7YisdupOkhz4fnnn8djj70WK1a8qqXloug6zXp96ZH6+vqc56pan0LvvzHxumXFD5ukpkSMif+OuReaY623O8YOYkh954Rvf2mtN2F/2d6TWMqUsZ5NmAdqQgghhBBCJjKPPfZa3HzzKciyYQBvATAfoQ/VhJBqyFS3vmYskaGhIQwMDOB8AFNan+nfX4Q0aA6AJZFycxmzE8pKMiXdU2Xq5ZZa6g0hpY96US6l7Hjsn7Jlmt/52WxvrPbPqO8rW99gzlZqXI+JjyrWIPG3F61flyZ6GxTtH5+dViEzhbG4Xrr6LmU90MtFZSFo/Vv2fTO07FLPNVI7JWL6NgRb34bMtzJsthv7p6JlU3UtQ2a3yoWWPW/yd3Dhc+/BCBqoYRUOxjdwFj5Wqcya/gbnll2WPTfHuu1J2Oyyl2t0Cpybo3kWwAIAzWYT/f398sVqHNJsNhVWj1f7qNVq7cM8ZzsWBlzjkjFoOZdlWccRI1PX3axHl+mT4Spn9kmIrrm+0rWucwst54uMSaiuMTLr9bqq1+tqsPV3rC2k2lBoOV/fliFTtzvbvEntn1zn3H6q6B9T90ajoRqNhhr0zIvYuVnGPCnTDqQ1KHVMzL509Wuj0UjunyI2a+rUDZndLGsrV8RmpbGVykrrgWk/uV3kh6SDvtbG2Lupa+ocy+Xnh2RP0jxxzcWQvo2xg9B+LdNmpf7oxjyJkRmraxljUsXaXkTmrrueqAClsmyVApQC5hXeV/j6sq+vr32U1U7fHqTMPVAZdiAdqWtBkTU6db0sa39prpf6Ohtje7F2W/X+0nY0m03vs+ka4fJtjVEuOb5TqmettdZarcfKlVirr29UvECmffNnxne047+Uioopy/9WKBbvEiLDhXQ+i/gWXh8/X6xFaNticj7GIPVXTLmq0OX42j08PAzV+lfKE1jERlIx69Xjbn19KcU6peZD9LUzxt6levV5LekqxWUppbDjjju2/3/77bc75evzxBZ7puvns31pXKQ+kd5lUZZ9mXlny1rnUnQARttd6roSE0sf0w5JP7MePR7Vh9WeHPdqqb/0d4i45pDr/7HXufR1lfXFTIbEo3fUaZHXoY8Fqaw0b319oMfZrly50nldqj2b15p9WdW7UMqa4zF9KZ2/+eZTAfwZSs0FsBih7t5SnT59qhjPmHdr+NYDSR+twkI5j6U1J3Uf6Ssn2YzUP93Yl5l1Sm0p67nD/Dx1b1VkDXKxRjxQE0IIIYQQMjFYBMZNEzJ2YNosQgghhBBCCCEkgQnzC7XuahDq0uH7id+sR0JyH3jxxRdX69j6O8ZNSXJljXHNKsvl1FWn7VrJtTbVvbCIu45EWe4fUr/nf9tSmcW4E8akWYhB6gOpn2NS6EgyuxWKYK3HkibHJscl00eq65qEy80VcLuy5y7N2223Hf7xj9n45z93wlZb/R5Tp17dvvbmm2921iNRlmu0lPLPV4/et85zlnrMNDm6TQe75FncZ2PW+iLumDqSW6I5T0Lnn29+SfNEH0/XuRzXmmiTKfWlHqrgI/S+aRIzXno7i4T3uGxRFbgvKEs4mXk+FMktWKpTmpvS/EpNv+nToSw7iBkT6b4Qky4pKP1dgO4xVOESb9Ybk+o0JoQohlB7893DYgjtW9Mmkuy7ohA9AB3pAAGtLy0yywoBKcsFPZQJ80BNCCEkjH/8Yzb+9KfPIMuGodQ8bLXVRzseqgkhhBBCSBh0+SaEkDWMf/5zp9bDdB3AKjz99Kxeq0QIIYQQMi7hAzUhhKxhTJ9+K5SqI8uGATSw7ro39lolQgghhJBxyYR0+S4SV2v64NvqtaWsMWM/pDhSZyoTpMdlmeeLpBgIjUf1xSBI8QtSvKekn5QexYxVydOV5ejxXWYqsxdeeEHUIZTUVGYxFCkbm67MFQMkpXqLIdUupXRAqTJj4xCluHYpvYU0v2LeEWD2T2i8kFIK119/AoA/tdOu3H//Iuu1MZQVn2emtIvpk7JiQWPuIdJ49uIdD6m6Fxk/aV2R4pnLTFlo1ceTysWH1D8Sps2Gxv3H3Ktd/Zwj7WUq73dU804MM+4/hpi4bV/ZUMx+1uNIffM0dI9k2k/q2Mb0R5EYYf19HjH3W/M9F6kUeb9Q7F5dBdTplFHwHStl2XfM+w2k9bLIPjGUmPcJVMGEfKAmhBAik2VMu0IIIYQQUhS6fBNCCCGEEEIIIQlMmF+o9Z/2JXdLnzuFlH5LpyxXPlM/E921xuf66HJHiU0PprtmFHEDkkhNx2PWa0tLlZOnK7ORu3iPtP4uKz1STAqpVPe4Ilx00UXtv9/ylrd0nLPp4HJZklx7pPRgEkXCFNoyA/rROtYOmdIYBbmgS/It7otlpbQzMd2oY0IuqtBHwlxHylxrbXIATfcA1zUT/drUNdr8f1nu81W5tUohDkXc7Kwusa0xSQ1xKELqGp1qszGp52L2Mj6kVGsSkn2ZaXJiwuAkunWvdFFkboburcy0R76QolD9Uu6ptrLm/SQG3XW7ahdcG91wA47Zf5dVtixXcUkfwJ4CMHffj9kTlRVSJD37xYxtGXsi/kJNCCGEEEIIIYQkwAdqQgghhBBCCCEkgUz12n8mgaGhIQwMDOB8AFNan+nOBCENmgNgieca09EvrzekbKpMlw6zASx16FNUpssVI1ZfSVcTm+4pY5KTy4w15tSxdJUNcWspW2ZMudm77db+bOkNN1Qiz7SDboyJLrNbc7NoWav9GP939V1RmVWsl2WVLWo/oTJtfVC0nVWt0WWWK0OmZKdF7ps2174QmS7GY992q5xetpL9U0n7ihiZZZcdK7qG2H7Za5dJFTJ70bdryhpdlUzbHjz1+SRUplSurLXLVc+zABYAaDab6O/vlytX45Bms6labQ46sixrH/lnC1v/1mo151Gv1zsOs6xLhi5HP2zlQo+QsrY2DLY+j9W1iL4hfZsqz9Q9PxYGtMs2toNAx9hKNmOeK2oHUn+46qnS9kx71/tVulbqH8m+TN0lmy0yT4rYnt5O1/owGKCXTX4u09YHPrvw2XuM/bjWuVj7iRmTIuV8ulY9T8qSKc0T0w5s9ZSha4ztucoVsT3zWmmehOiXH6997WvVa1/7WnX1+utH9Yt5X+jr62sfvbL30HJS/8SMiXSYNhszJnrZ0HXOdo+P0bfRaKhGo6EGI8uVNU/KsgNpvultbDQaPbE9V79L+pQpM2ZPG9KX+WHuSVz7T9f67SoX087Q+VWmTOkoa18q7aO7YbOh97D8s2az6X02pcs3IYQQQgghhBCSAB+oCSGEEEIIIYSQBPhATQghhBBCCCGEJDBh8lBLKEue0Gx4GPV6XcwTKuUiyzy5SSXMskrINxiTD02/NpehWvVLeaFVSe+ly4w8eHo7pdyWZjlJH985XWZfX1/HeT0HZF6Pgr2PMyHvXX7OlvM4pi9j8qiadquTmjfUZ8PtPrLkS5Zkqog8irZrXWOiU2QOSfkGzbIhfRsy4qFrUEx/mX2g6x5jE0XyPEvzpKp6UvWV7KL0NTCgXmmedCs/a2q7y+qvmHpirt1www2xbNkcnPnCUQAuBbCofU5aP80xWblyZbDMskidU9J6XsXcVEauZB/S2iVdG/K5i/yeX9Radbm/+MUvsGTJJrj11unYaad/4otf3DOpztS1wkRvo5Tru5uE5tuOwdwnSoTOcRNX/+V7ktC5WSRPt6suG7bnlVym1AdFxkTaZ8Tks5f20WVhtZOW/Uh7vVQbXSMeqAkhhBCyZrBs2RzccMNncRNWAXg/gPnQH6oJSWXJkk3wxS/ugVptBJdcsg2AeaBtEULo8k0IIYSQCcPy5bsgy4YxggaAVQDm9lgjMlG49dbpqNVGMDJSQ602AtoWIQSYQL9Qh7oamC5LMe6zustJERcqs6zkjq3TaHQOl+kK4nKxjnXNCkVyG1FKBbu6lDUmpru45P6ku5vY3Mwl3XXXGqc+yNUqp9/zPlAY3R8xYQKSm2lMWIDeTud4BbjwW+tMcP3P50Y2PFzIxcrnAi5dK6Hra45ljJtUqvyq6IXrrz4mUihCTJhCEXQX/iL9oYeolOVqXMStVHJvLBKaJGF1C7aEEJnXmmvQ/fefDeAQ1LCq9VC92FrOJV9Zrkt1U44ltZ6y7FsaW5/bbajuvuuksJwYl/i8nsxw143R1eSSS44HMAhgFUZGOm3LxLdHkki9L5RFWf3lWjuyyDXD7DvJDqT+MtcKvaxvHZP6oPTwp8h9kN6vtVpNXLOLrNdS3wbt1S2UdT8JtVmllLiPTpU/YR6oCSGEEEJWu+DOx8GYi0EsBl1ySXmstq3Vv0wvBm2LEALwgZoQQgghE45FOAaLMNhrNcgEZBH4IE0I0WEMNSGEEEIIIYQQksCE+YVa8nm3+ca7XmevxymbMbipcX4+f3xrjJKFIikRyorviCFVTuhYmtf64mpsMUkpabMkTP2k+JyY1Gvt+JjhYW8sfSimfDO2CHgpHseUERqrbqZsS43v9tEez5JtW9dXiqeOiTczY6T0WB7JfowToz4qK0ZKoqp3BMTMt6A0Ipb3RlSVVkhfS4r0jx43HRNTViROU0KKZ5bWsiJ9EJOiSUrLqOtrErMGhcbymgTFIY8WXuidE2XZQWjMsi2dYigx6QFjzoW+j6ZblLGu9Ioi+x4d194hZL2U4sir2F+ae6D2tRZbN+XH2GVV+yBJRpFUv2Xg6i/bHtzUNTSdcZF3fZSxZxpbqw8hhBBCCCGEEDJOyFS3fq4skaGhIQwMDOB8AFMCrte/68gbOwfAEtu1Ab+UuMqmygwhtex4khnbr0Bc33ZjTKTvAIvIzOudDWCp+U2j+c2fpXyIzJrlG9jZAJY66vSRy7T1e0i5FKq0gyK2ZyPEflz95SsbUy6E8bSOTASZIXYwVnQ16cY8qbps6tqVl11qfFblumfTtVsyU+im7eXMrlBmmeXGq8yQfU+KzG7vo6tau7oxNzv2iIEyisosWi60bJl7tlhdnwWwAECz2UR/f798sRqHNJtN1eqb9pFlWfswz9VqtfaRf7bQuCY/Go1G+7Cdl8qmynS1Q29LSFlJV6l/UtvZDV1NffV+tfWt1M56vd4+fLqG9JetrC6jXq8H6+o78voGDRttNBrOPvHpasro6+vrOGq1mhps9XmR8fTpFmt30nhVOTcl25NsVtLVZ98ue7DpG9LPVc7NIjLLWkek/pHmV9H+SbEDSWbMnK5qTEJt1tTBt0aXZQdSm2PWA6l/pDGQbEgaP2lOx9yfzXLS2lHEDqQxSbU9X7nUuWn2QX4MFtC1iP10s2wvZbr6XZo3IXYQs2dLtT3bPis/YnSN6Z8qxkS3dd96NdZtz+zrMvdsqbo2m03vs+mEiaHWYx/MmM4Y3/jQOOXME09hi710xaNK9cTILCtvYSbEn0nyMyOmS2qLji9/nk6RPIHWHLUOXUN1l2T4iJEh5aGW6jH7NhPiDm3vDFBY3ee2+Ooc55hY4i1NGzbldYOYeNTQcjG663mL6/V6R78XscNu5KU29SkrbrussZfqCVpbA9YuaR0u0o4swDvKRsj8H3VtYrxuFrBeSvcFPdc2MDrftl62yBod039Sv6fadOpa4ew7y3nzb1/ZVPR6Y/YyJvp4+sYndR65bEQVqBOIu29lWRY9v3yY703R7xkx+ydXO0JyQutribmOxNhBzHop5UC3rhUB9Va1v5Qo694csj/J92wxfRKDZAe6zCJtNnUPrSumXBX9wxhqQgghhBBCCCEkAT5QE0IIIYQQQgghCYxrl2/dxUB3gTHdUyVXXxObe1NOknsTynM78mFLv5O7AelU5ZaY6vroc1WRZOauUNnwMBqG+6xEWW6avjQdVbjh+vS1ud3kfSvpG+oub8qIca8y5Us2G5PeIjXEwXS/LitVibR26Kk4Yu1D17cqly6d1DCOZDmIc3tNlWHWE7MeFAnLCZ03MW2WrvW5Hoe67PvSTUro+pgu3iYufVRA2ppQYu6Hofc7nwy9Lb61K9X13yR1LxNiT65QIGn9lPRJdYOX7icmSXPKsu757vnt/V6Ja6W5r5Hu8SG6mfWEaOqqu8o9ravuIqFRks269iuuUJcyKPKcUek93/F/XV8zXE2/NvheaFnbiz5rhZC67kvwF2pCCCGEEEIIISQBPlATQgghhBBCCCEJ8IGaEEIIIYQQQghJYFzHUNtSReSfuzBjJk1f/Zj4M59uNpm1Wi05TjMmdtaM29bPxaQukXQwY1H02FBfvIkUuyelAzPP5TEcCuEpz2xIaaHM8dJjfX2xHqmxGGaajLYOAXWEpjkpEpOYmv4qJMYu5F0DZcVMmenIYmIC9b6NiQGKaadrjtnKlhV7GUNQSrTWeqDP+ZjUb1XETAP2WMiQeWKuny+++GKwrqnttMaclhDXFxrbWySWXi/riz+1xuA53neSau/m3IyR6Spn6iCV9d3/U2P7YtZz890jUhyptS0B6ZKC3iMRgHQPi9lLpcRQF42dLeseK9UjpcYEwuPaY6jq3RpVvRdE1zfGZqT49KD5H7COFImZTl0PpLnp63Npnx3zbgZ9jhVB2lfYri2avlisP6kUIYQQQgghhBCyhsMHakIIIYQQQgghJIFx7fLtQvop33QR9r0iXqftWtNy3Q6VGZPWoIjLi9UNyOKa5XNB0ZHaabpX6G5k9Xodr3/969vnnnzyyY5rr7/++mAdUl3kY8bI7OfQ8fRhc9vKXU6kVD1F3Nd1TNv73ve+h5tv3hx33TUDV1xxAoBFheoF/CEEsamCQtzszPHR3d5MQt22feEYLnvyuV/DOG/+Lbn2SeEQkgyf63pouiRJV/O8iRleI9m0NE9M/XR7k9Iw+dZO25poG0vz/7qLt4lvzUlNN2dLF+gKW0oN65BSEBVJMxgaRgW4+8dM8RVSl61On35meJYuw5QvudbGjHtMukCJGHuKCZWSUhfFpLhMpUjKNt31NqasJNPn+qtTVtqzkLHNdfWFVZRBzH2hSMo2V50+ylorUtO5FVkvY4jZI4We8xFzr9Zx3dOK9o41NMkhc2RkJGkdCWVCPlATQuzcfPPmOPPMA1GrjQAYBDAfqQ/VhBBCCCGErOlkqltvrymRoaEhDAwM4HwAUxLrmANgSWSZ/LuP2QCWGudCOjFFZmpZU1dlOZfj0n0O4tqZfzs0WykszTJM33DD9jnzl6QnjF+sc3ll9k9IO/NyoX3ik2li+77VNiahpPZRXm7hhj/Gjx5fgGE0UMMqHIxv4Bh8rJC8mvmramtJKdNmY8pWJdNlI0XHJERGSNmQemz2XtXaZa4Hobca35jo9jbiqLPMMYkp2637QpZl7X41X1SYKtM1j33lQik6JlWt0Tox902T1PWgyLqXIq+MspRZTbkyZHZjnsSUi7lvxuzZypIZwni0g27ILLp2pcjsdrlnASwA0Gw20d/fL1+sxiHNZlOh5Z2Xeixs/ZtlWfBRr9dVvV5Xg4Cq1WodhyQrL7+w9XfItflh6ht65Hrluurn8nbkh9RHMe1sNBqq0WiowSxTjUZDHXjgge1j99137zikMSkynrY+kHRfGHFtir5mvfqY2Ma5DJlSuQ996DcKUKpWG1aAUsC8wvL6+vo6DrNsaDslm42x99RyPpkuG7H1kWse2/pWv86UIa0HkgzXHLfZe4z9SDLNc+Z6INVv6wPXmNhsreg8iVmjJZm+daSMtR1AR79KMmPuJ655XKRfY8tKuqau0b77um3eDLb+luamNMdC5entClmDUu2nrH2FWS5m/1SWzJhDn9fdsNm8nVXPE6lcVXuZGDvQr4m5b0r3vxhdY2T6xjLFDor2axljUlZZaU4X2bPpMkP2Sym6ltk/zWbT+2w67l2+szz2LTBmI9NiajLLryZ67KEZd1gklkcn9ZX11tQpwv9d+GKAMi0uIqad7RRErdQEv/3tbwHMA7A/gMXIMrtrcVkxZCZBsToB6T8kfLE6UpymPl7mGLjG2hYjLGG28zvfeSOAeRgZmQvgSkju3nmcZsMT/5oagwfYUxelIMW1m32r62PO6bJSvUhtltYgs5ype6gMKdVbkTkm9aWpj55GzyfP1hbl+Lys9wu45CulxPtAWXJMpLh2a7+31pCy7kWmF5GkT2qMYhHKii0OnVPKiNs27UBKtWjKiNFdLyvd4317GVe5IpjriMmee34Rjz32Smy00W345Ce37zg3f/58Z70x6QpjKKvdOt2yfckOJGKu1W3Ih57K01yDU20vKb464R0rEqn9PNaoah8dMrb5/qkbNiu1M6WenDL6a9w/UJOxzDysjtNdBeCjUOoQ50M16R6rx2DRuL55EEIIGTsoNQ9/+MMnkGXDuPvuN2G//ZZg990f7bVahBDSFZg2i1TI/lj9MN1o/Tu3p9oQQgghpHyUmossG4ZSdWTZMG69dYNeq0QIIV2DD9SkQq7ESw/TDQCLe6oNIYQQQsonyxa3H6aVqmOnnZb3WiVCCOkaE8blOzSvqg89dqdIXI8rlsCMy/KhxwukxoVkWdbxfynfqK6vwuhYMCn+bHQswyKsTss0F6sfphdZQ3V8cay6zCpiq1Rkfl0d35i47NIX/+76f1En7Rg371WrVkG1/k2N+/dh67+QdxTo8Vy5ri6ksTVzJUv2FWMjof3l6ztn/Gdkn5tzTIp1ktbSbsTKtte8Vi5g1/pkQx9P17kcaaxjclvqFOmfmDjE4eFhqNa/ReZmaK5SX3yeZE+SzZrz2NrvrfW5SFyyTmhMoK/vJPuJybVryrStTzaZMeuIz/Zj4spdugILAcyHUnMBLMbnP98Z3iXZgdSXpu11I1bcRO8fc2ylvi0Sp5nalqr6IGbvlbofD31HR5ltDLmP29a9XrxHIqR/QtYu5/uYLHvh0D2/qY+PsvYyY4kJ80BNxiqLwDzHhBBCyESH93tCyJoJXb4JIYQQQgghhJAExv0v1G03h0C3gRhXX6dblEWW5Kasp4/JsizKdUZKByTpYLpFSO2Kcf+IcbsJTQPjc3cuK5WC7ppljklZLkSSW6LkwhjjWivZGpDuFrj99p1pTu644w5g/nyowUG86U1vwqOP7o4VK3bBtGm34OabTw3S1UdqmoWYuRlSj4LfpS1GP8ktsIjtlWWn3Ug5EuNmrhMzJlJZ17lYJJd4oDy3s9DUj1K5WFJdfWN0kM6FpkAb7V5cDWabeyFTJ9XN1levVFaSWSRUKtSV3dRHcvH0pRJNvS+YxKQo1IlZG6pKe6STGtpmXuvbd1URjiER0y7pWlcomc32Kk+XZunbJJdqS9mY+8l4zgZTVhrUUMb9AzUhpHoefXR33HTTSciyYTzwwKHIsj8zBRohhBBCCFnjocs3IcTLihW7dKREUWq/XqtECCGEEEJIz+EDNSHEy7Rpt0BPiZJlV/VaJUIIIYQQQnrOGu/yHRpzC8TFykixaWURmkYkNjWPFMsXE0tURRxNkRQxMSkYzLRjNjJbyidXDBdGpwNK7Z+kGNeAuO0777xzVNmFAA5pl7upnRJFT4FWVlxWTAyZ1M8mMfGoMdfqfesr51o7lFIdcVu+dDbdThPhi5ULilWLfL+BL260ihRNReLjY7DaaUD/WNfhVjnzPhX6HpAsy7oSO2uV7yhXVvrLGJmp73GQ6i3y7pFQXvGKVwAA1n34YbziZS/DPffckyyz23GSvjkuvXskNBZ0dZGxFf8Z886JKkiNLTbP+9YDqV4pjjX1/RS+/UCoHYS+08FHzF6myLOClJZV2rsXiTkPLeerpxtzM2Ye6fuDVDtY4x+oCSFhrI6ZZtw0IYQQQgghOZkaa1/hBTA0NISBgQGcD2BKYh1zACzxXGN+L5N3VEjZVJllly0qc6n57ZT0Fs+CMqseE71sajmd2QFlbfXMBrBU0yGGon1r64Mq5KWUrap/Qr4ZtfUPAnWYg9X6ppRbAs8vro56u70eVG0HqXMzRmaMHZQlM7Wc7zcLBbv9rD6pOq6TZI619aAbdlBluW7KXHeddQAAOz//PP669tp4+plnkmWONTsY7zLHk65Vy4y5h4Xcf8dqO3W6tdeT1svUvcxEsr2Ycq592LMAFgBoNpvo7++XK1fjkGazqdDK4JEffX197WOttdbqOPTr6vW6qtfrarD1t1lPlmXOI79moVHGd/hk6ketVrMegx7ddP30egYtdfr0zeuLbacpM7ScLi/Lso6x7Ovrs/ZlfsSMiV7OlOnqd1s7pP6RxsSUaWtHSN/67MB2pMoMGcuy5kmq/ZhlY8rF6Cr1ra9so9FoH+aYhNqPT1+pXJG+1eWFrDnmvOmmHUgyTf1CbVYqF2vv0tzUj5A12yVPsgPJ9qR2x9hBkTGJaWdIPy8MlBEi09fm1PtmzJjox2GHHaYOO+wwtXTTTdVhhx3WEzvQ1zV9bYtdu0Lk29aD0LFNsaFelNPLhoyffk/P95dlzU3p8O1pq1gvi/RtN/YHVdlB6BEzp8vas1XVzpB9hm09CLmPpurabDa9z6Z0+SaEEEIIGWc88sgs/PfQAXjkkScAXNhrdQghZI2FD9SEEEIIIeOIRx6ZhWuv/RT+hFUYvrYB4FrwHReEENIbmDaLEEIIIWQc8dhjOyHLhjGMBrJsGMDcXqtECCFrLOP6F+pMSwO0cuXKoDJ5ugYFe+oGJbxaPhVTplmv/n9n6itDNx/5tXk5vayZZsWUKcmRXi0fk/YhE1IwmGOpX2uOWUx6Ar1s3gchKazM8Uq1EbOduj6SDKkeH2a9vnQlOiMjI+2xNFMO6WNv6qP3bb1eF/tL1yfVfnQdlOXcKaecgjvvfAXuv38mttzyQfz0p+8YXeH8+VCDg9hnn306Pv7jH/84Sobr/xJ6O830aanpm8pan6R6Y9rsG7OY1FgufUwdYuaNibWehNQ8Mbj0U0aakxiZS5d2vhJv9uzZQfJ9fZW6BsWMiZRuMv87ZG2X9KtqnkgyU8vF1HHPPWcBOAg1rMKIagC4ytnWIukmQ++pIXW5kGzGvC+kriNVUWQNkpBS2ukyfHtanSJrqW0f5pIZkprSlnbUpKy+DKWqsUzSoUB6wo56Asrm+7tseBjmi4el9FuSjRTpu5B7j+2ZKGa/kpqiTWJcP1ATQoiPO+98Bc477x3IshFcd91r8Y53APPn91orQggpwiIA83Ew5mIQi5Fll/RaIUIIWWOhyzchZEJz//0zkWUjUKqGLBvB4sW91ogQQspgEY7Bx8DYaUII6S18oCaETGi23PLB9sO0UjXMndtrjQghhBBCyERhXLt867HBUpyUFCsnXVtWvIIUnxcrJxSpHTEx02a8tRSjExPPnBqD54p7CIm71fHFAHUr7i4nNI4txFKk+PQYsixr26wZL++SB8h9K/Wrz36k+Bzp3PnnLwBwHpSaC2AxDj30JdfIz3/+8wCAt957L37xxS+Oij+99tprnfXGkBrzFlpn6LUh72IoKz7WRJqf+jqj27r5/gegcw0oa+0KjQuz1SvNjRj0/onpZ9Nmg+aJ414UWo9EWfcz39oetEYrVWoMvIS+fkm2V1bsnrleSvuKqu5nSXukgNhQKZa+rLjp1LWsyBoorV3m/yWbibmv29ZWG756rDbUGktTP0n3XiDtn8paL8soZ+pQVTnzfH4PU4hbn3xrkITeRzHEtNM6bxLGJJRx/UBNCCEhZNkivOQW2d0vSwghhBBCyMSl918dEUIIIYQQQggh45AJ8wu1lGJAoqyf/SU3IJ+LguSOpbs7xciU6Jb7Xlkug/rY+lJ+xbhUucrZ6g3VVaq3fW3L5SQkXVoIRdyoJdpuwh4XvbLsyefiGeL6D/hdffW2fOYznwEA7Kj9PZYJdZssa7xMyiobms7NZntBKe4srr5lzfFup+JwyXHN6dB0V0XSJZVFTH/FuPDH3Hv0a/WUdvV6PcoNX1+/pDXH16+h6dPMMI4iKe10gu4nlpSIuk7m375zJrZrbfcFKQUpLNdL11axfzJl6GNrhopI92pJVzNNpWl7ZbnIS/qEhtPo/y/f4dZNWe7FoaGlZd1vTYqElobWk7RHxOg1yDe/UueRuQZJtudMQ+x5DjPvH6G68hdqQgghhBBCCCEkgUxVEZldMUNDQxgYGMD5AKa0PtO/Cwlp0BwASxLl28qa31vZdEiRmdc7O6Fsqky97FLjM6lvdV2Xeq51ybPpqvftqG+gW+abl021g5Dxc5WVsOmTqmuoTJv8ssekyrKx/Qp09q3PZqUxSaHKdo4VmeNJV1fZstboIrZnI/W+kDqnU2UWKecqGzMmVa3RNn1sfRsqv2jf9novI2H2j0mV+hadm93as0nlxBdgtf6Ntb2i93hg7KwHE03meNJ1vMjsxp5Wn2/PAjgcQLPZRH9/v1xQjUOazaZq9WP7qNfr7cM8px9Zlqksy9TC1t/Sta5joeWzWq3WcYSW03WyHXl9gwHlYmSGttNslyRP19V3bYyuuvy+vr6Owyzr0tXXPyHjl9K3Nn1y24uV55IZaj8xckx5IX1Zlu3F9qveroXoXAts64GrXJF50q1ypg25xsR1rpu6xthsWbYn9U+RNVo/XPZlWy+r6p8ic3os2UHMmPjmtcsOfHrp/ZzXPdiSF2s/IePpKxdqP1XtZaT7idk/MfuDKmwvdI6XvWcL1dXUr9FotA+XPrZ5bdq+NCZl9W1ZtjcW7kXSehBjs9LcKNN+Qu2912MiyQy9bxddo8uyH9c6kuvebDa9z6bjPoY6a33jp/vKS3FZyohtiInLssm1yTB1aMt0xDaY/7eds10R2k4AaDReGuqYNC+Srq4+UJD7w9TVFwOky1y5cqWob8gr/nVSYotjkGI4pHGXMPs91H5GRkai0qeYc0UnKHWRxd5T55uJy76ykRHvWJYVT6i3S0prYvu/C7N/zHLSOldWrFwqKXYZQsw6J9lsjEx9HHwxiTG2F4pP15GREes6a2KOib7WNup18V4gxfJK88Icr/zabHgYZgxjzJhUZd+6DmZKu9B4ZhPJZs2+a/dP5L2oXc4R2yndq2P6Xeofqd7Uc0WIGaOy5qrUlpg1SNo/Se9JiEnDWFa/S20sIjM1PZhvXyHdq0PfyWHuZWL2Us56UZ7tSzJMOTFjIO3lzXtxTLvMvnXpav5fWoPMcpJdSOdSx6T0GOqTTz65/cKl/Nh+++3b559//nl8+MMfxgYbbIB1110Xb33rW/Hoo4+WrQYhhBBCCCGEEFIplbyU7JWvfCX+8Y9/tI8//OEP7XMf/ehHsWjRIlx44YW46qqr8Mgjj+Atb3lLFWoQQgghhBBCCCGVUYnLd6PRwCabbDLq82azibPPPhvnnXceXve61wEAzjnnHOywww7405/+hNe+9rXRsmJ/mu/r6wMA1FatQl+jkez64HMtcLlX2ORJbmW6O6HpFhHjAhfj5q0T0z+haUxMiriRaRd5UwW49Mk9KVwyJVzujTlSn+S2CPhd2WN0k1xgYuZLlmWFwhRs14W6D/nQQxiAl+xbWWRKrj1mqhKTVLfAkHljk+nrZ91NyrQtvZ0xrsC+8BWJ1PGTyMc2xC25DDnA6PUxdS0ba5j2o88Ts81FwjGkNVqX6XJ3FutxrEGpNhzTzlSbTknXZFu7pLK+NIMhMm1UFY6hr3tlIdmEef7EE0/sOHfaaaeJdYUS07ep7sVSO6VwLJ+ubX0C2q7Pm1xmSJhCN9zwY9aqImFvUihQDJKNlGEHtvpDXKOz4WGvPYWk8gshJmxA6neprC08K7dZV+gWkG6HlfxCfc8992DGjBnYaqut8K53vQv/93//BwC48cYbsXLlShxwwAHta7fffntsvvnmuO6666pQhRBCCCGErOHcddd2+O1v/z/cddd2vVaFEDLBKP0X6t133x0//OEPsd122+Ef//gHTjnlFOyzzz649dZbsWzZMqy11lqYOnVqR5mNN94Yy5Ytc9b5wgsv4IUXXmj/f2hoqGy1CSGEEELIBOSuu7bDz372TmTZCK6/fg8AP0OWLeq1WoSQCULpD9RvfOMb23/vsssu2H333TFz5kz8/Oc/x+TJk5PqPP3003HKKaeUpSIhhBBCCFlDeOCBLZFlI1Cq1vp3LgA+UBNCyqHytFlTp07FK17xCtx77714wxvegBdffBFPPvlkx6/Ujz76qDXmOuczn/kMjj/++Pb/h4aG8PKXv9x5fYhPvbLEIMbU46rXhhkzmRLfFRJfVUU8o0SMjKCYxMg4aGB0yi0p3tJVr/m6f+lak5g+MHWNiZuW4s9S01LEpMIxKSsGKDqmu0VM/FJIjKQrDjE0DYQvTZxN91xmWfM2dQ2KifeWYuJ97zewxX/a0OP6RkZGomJeddtztSWqHvhtVkptKBGz7lWVZkgnJqZMkm+uwXo7ffF5UkxgTLyuZAe9Ti9XJAbRloLQlW5SR0qf5isrYZbT5bjGK2QvY60zYB2R6l2y5EtQ6mIAq7A6Y+yVzuvN/pHSFcaQ+u4R6dqyxtKHrd6Q+P2xRsh9MsdsW2rfpr7DIOYdAT6Cnoss11We1iugftv8s+1JYtJN6u8wAtLfM6VTSQy1ztNPP4377rsPm266KWbNmoW+vj5cccUV7fN33XUX/u///g977LGHs45Jkyahv7+/4yCEEEIIIcRHli1Clr0ZwDdb//LXaUJIeZT+C/XHP/5xzJs3DzNnzsQjjzyCk046CfV6HQsWLMDAwACOOeYYHH/88Zg2bRr6+/tx7LHHYo899kh6wzchhBBCCCE+Vj9Ur36QruiHN0LIGkrpD9R///vfsWDBAixfvhzTp0/H3nvvjT/96U+YPn06AOBrX/saarUa3vrWt+KFF17AgQceiDPPPLNsNQghhBBCCCGEkEop/YH6ggsuEM+vvfba+Pa3v41vf/vbZYt2IsWGSvEfMTF3kkxfnsmQmOpseNgb3yHFGaTkxawSaUxiYuWkvKomtliLojFAMXmEzXzbOq68yjZ9zb6LsdOU+L1Ye+hG7kZfv+tUFXekz82YPLhSTKAZLxwTIyjFvMbkrLXJy9eu1Py1ZlkpH7Gpq3StJNM3pySqWgP1Mao8Nq2gDKuuCe+5kMY9Zj3oxj0s5r4pYdqe3s6yxt28n0h9UCTvtPVebXnviE+mvl7GEBMjGVqPD+leHbMmmwS9w6TVt/q10jwpq39MpFjxmLzn3dhPmsTkTo55d0wqRd4ZIK2ftnKu952E6hCzpzV1tbbDgfT+lZD31RTdu8e8wyiUymOoCSGEEEIIIYSQiUimevH1UUGGhoYwMDCA8wFMiSybfw8yG8BSyG9mNb9fya+dA2BJpNzUcqa+Nn1CyqUMcjfbqZdz9XuVMlOYg7gxkWSGfkNnLRugQ6/6xxzPssZyrM3NMu1dx9VfPjuIKRdCGXYgYdO98NxM+NVyPLWzcl0tvzJVLbPMcilly7pvdtP2UtbLnNR29nK9TKFXexmTmDU69L5Z1V4v5L40VsckdX8wFvYVUllpr1fa2iXIkMrF2I9e71iZmy6eBbAAQLPZ9L8QW41Dms2mQssLMfbIskxlWaYWtv6Wrq3Vah2HWVY/QmQvNHQIKavLNPWJkZlypJYtu5zUV41GQzUaDTWYZarRaAT1pV5P2f1Tr9c7jtT+MW1EtwNfWZv8kHI2+xpP9pPSt2a5quaYJDNmHUldD/JrBlt/d2NMYtbaMsoBL9n+YOSY6OXq9fqovpX6WZqbIWNUdJ6Ya0SITdhkSvcl6d6n959rzXPJrLJ/Qsva5BeVGdKXKfei/H6n3+vyctK9p6y9TJG5Gdo/Zh91yw66US6kn0PmibR2FdmbSnZqW2NC7idF9jKucrFt1MuG7NFC7F3qnzJtNvQeH7MXlmSWtQcKrafKuWkbl1R5zWbT+2xKl29CCCGEEEIIISQBPlATQgghhBBCCCEJ8IGaEEIIIYQQQghJoPS0WWORLOK1+JklfUsKfX197b/N17Mr4wUlIakUMqUK6SNh9k+mvX7fPKeEV/i3U44MD6Ner4vpriSklAfmuZi0Wbq+egqPhqGrj3ZbLG0y01ukpp6J6S9JhywiFYfV9iypnWzXVoEvhZQVS7/FzP8Y9BQ7JqbuoWlPfKjEFClSKqoitlYFecqh2qpVaDQaUekt9HQ3vtQprr5UkWutXjYmXYuJdB8IlW/7f2o9rnO263T7fu1rX4sVK/bG0NAs9PffiLvv/qqz3iLriGTD0twskk7NJd/UwdRHWoPMNVoaB0nXstMlhuDaO9hk6u30YZtTtlRm5nwz9SmSplEnNfWjZCMxhI6f8qQ2jEHap+bnVOtvcxz0/6fOL5sOvs9d6PvoVPnKSA0Vo4M0/331SGOvr2Uxe2EJ39qln9f30eaeP/XeZ6OK/WaRe7WLNeKBmhBCCCHVs2LF3rj77q8AWIVlyw4HcBeART3WihBCCKkOunwTQgghpBSGhmYBWIXV39evAjC3p/oQQgghVcMHakIIIYSUQn//jXjpYboBYHFP9SGEEEKqZo1w+ZbiMFxxwFK5bGTEG2cQE8Og++674kaVRYZ5rS5TijsyccXgKcs5Kc5Pj18044xiYonKipeQ4n7bbVQKw8PDUTHCQfFwhhzb36lxWTGYMq3x1ZZr9f+XGZdlEmJPNmLsKSaeMTUu2USy/6pi3FzybNeWpYPtvQQ5+noUE3+Wx0yPYPT7J2JwxnBadAhd83xyisTrp657Rey5ipjAPfd8HJtt9nUsW7Y9NtnkTmy88boAFuBlV18NPPxwsAwftli+HP1eZJK61sasOTHvUDDrtcVFFkV6T4ovLtn1LhTb/uk//uM/2n8vX74cDz30aixbtgM22eQOLF58vLUen0zz/Q+u68rEjGuX7pu2ueDad4XsL0Ni6Tsvd69dJkXiRmP2bKH1lhVj7kOyoSow7cekrLU2Zp8qrfWp7/OJeadLyBy36RpDkX3hgQce2P77t7/9bZL8NeKBmhBCCCHdYfPNb8bmm98MAHjhhd7qQnrDQw+9GldeeRyybBh33HEggCuRZYylJ4RMTOjyTQghhBBCSmPZsh2QZcNQqo4sGwZj6QkhE5k17hdqKY2QieQK7ay3hdUNMMCVx+UilFlcxiR3sLLS5BRxEaoiXZGUisPs2xhXlZAUEbH1+ohxv9aJcSeU6EW6pBjXeqmdku5F0uJI9UpzoYiLteT6b8o0U6+5ZFTlSifV61sbQvu27Y7aSsVRlet/KDFrXlJKnUgXz3bZgHIxrr4xSDJ/+MMfWmUeHpDSLnWMzH7P14BseBjmXSjV3TJ1bQfkOV5W2qOy0niFrMmuuXnGGWdoMv4GpQ4EsApKNQBcWUoapJgxiUnVpaPvu2q1WnRKMpdrccr+xEeM223pqcwca5AUyqWHI3bjvmRinjvggAPaf59zzjkd517+8pcH1+tqsy2tmETqftMM8zSRwjq0Cr37dilUyqaPTX6ZBIVRtJDum/Pnz8ctt2yBu+9+GYC1kJKZYo17oCaEEEIIIdWRZZegVnszlJqLLFuMkRG6exNCxia33LIFzjrrTajVRgAMApiP2IfqTPXiZ6qCDA0NYWBgAOcDmJJYxxwAS4BR317ruDomL6sz6lvwwHI+8npnJ5RNlamXXWp8FmIsqTKL6lqmTH08Y+ygiMzQsmvKmITMKVvZpQm/eoXo6tKnzHaamqbKrEpXiSIybevwbKy29ZQb1Hi0926U0+8nKX07Xvon/5VltlJjwg5i7ich1/rk+Ui1g5hyvViDyiq7psyT1LK+/gm5p/VqT2uWnb7hhu2/d911145zl//ud8EybW0uupcpMiYmynKtea7M/WVom6vcP8XIu3iDH+PHyxdgGA3UsAoH4xs4Bh/DswAWAGg2m+jv75crV+OQZrOpWn0XfWRZprIsUwtbf9frdeeRX5sfeR0LLfXWarWOQ5IZol9+5LoMWs6FtHehpd7QvlroaVeMzBDdbf0aO56x5V0y9TbH2EGqzNCxXQiMstMi7ayqXJF25uVS29loNDoOSYeYdrrmwkIUm5tSG02Zpr27ZEq6FhnLqmTq5fQ1zzfuZc3NoutIt2Wm3k/yPh5s9XnVbTTbGTp+RWXmc38w8N7jkpl63zQ/C1nHQtaDUF19+qbagW9u2vYuZluK2kHMmEi2l9rOIjYbeo+PtffUcqn947Mfac+oly2rnTH7J/OzAw44oH089NBDHUdM30r3Ptd9XNobFx0Tae8u7St8urrsJ3Q/UNZ42vrWV066b77//ZcqQKlabVgBSgHzOs43m03vs+mEcfmWYjZs17liYzLt162sQFyGLUbBFW8i1aOn/5DK+UgtWyTuQe+DoDjIhFjCVHwyy0pho9erx/U1jPgzX5v12LUiKcmqoIh8s2yrgkJ2YMZMS/r50suFpjYr0uex8XkhMn36WPs9oB6p3pg5E/IeAOX4PKieyHhd1982Ga4+yCztj5kbWURsaH7edp1ej3kf0u8nRdb2Iu8p0JHum1LKIdt5mz75bkinG+ulKSMmtr6sd2Kk2kFM2izp2ph2uPQrSurYSilATcy5MDw87LyHBc1/S9mg93ck3DdjrtXXQf0dPbY6Qu5bsSMjtbPIHB4cHMQll9Rw9dV1vPa1/4711rvSr4NFZsy9UapHioUO2Z/kczrm/VDSuRCbtT3b+O4vejuLkJL6zdam733vYADzMDIyF8CVYAw1IYQQQgghhHi45JIa3v72SajXFYaHz8TLXvYh8aGaTFxWp/VblPwFDdNmEUIIIYQQQtYorr663nqYzgCswrPPzum1SmScMmF+oQ5Nv+Nz5ZHcSHSXE6mcJLNM97JuvJZecs30uW2GXiu5jZj43DbLcv23XWurN2YM2nagFIaHh5PSsISUCHVT9rn9hupnjm3eByGpeXQZult7rVYTXRhTbcR2Xqcs18OyUpu56rWl0dOR1q4ywypi3JQl/ax1OlJ46J9JKYhiZEqY9uuqJ7b2slwWpXrLsjsTKS2UdG1oqIGNmD6S3AmrcokNLefsg4C5meoS70rHZ1ujQ911feEGMfunmHq6HdLkw7U+xPZPWetB0hwLCJGRXP/jRCXMDcTtE2P41rfeCmAhgFUAGnjiiV/iiSfuBCDPkyL77xD38JCwHOva6uif0H1hzB5IWg98/aO3s8h9oSzKsKcJ80BNCCGEEEIIISFk2SIodQiAuUiNnSUE4AM1IYQQQgghZA2kaOwsIQBjqAkhhBBCCCGEkCQmzC/U0fGVjjiD1NgdKd7EF/uhxxoUeRW/FF+lp3YwU5xIKVCk+AlffJ4U61gWZioqXXcpljYmLcbqvpwHYH8AV+IrX9kXALDjOedA3XFHx7UxqXlS409NXKnWYsvFoNuaK2WOLQYoNMbVdp0tbYft/0XaJcUsxaTbSbV3M+7Ilc7N18LQ1De+a03KSpcUGlcfmj7Khq8vy0phJVE4hVxAvWWlgZLk+/oudK0vMp4xhM4Tk5h3DcT0e2iMeS/6JzX2M1YX/b0lJpLN6O+NqBvpJk3KmguSzF7EdJcVnxuz1hfZR0v7TWs9ATLb1wRcV1Y7RT0C+tmW+sqnj9S3qakfgbC46WxkxLt3cT1nuPYqOaG62yjrflw1/IWaEC/zAAwCOBbAIG67bese60MIIYQQQggZC/CBmhAv+yN/AySwCvfd9/Ie60MIIYQQQggZC/CBmhAvVyJ/mAYa2Hrrh3qsDyGEEEIIIWQsMCFjqE1cMQE2X/zU2DQpriavxxX7kZo/OiRuO4/D0ONYzJiOmDjImFiG0L70xXPpZc16zNzOoZj9I+m3xx7LsWLFp9BsvhoDA3/GCy88hJtuAvZvNr2xOlJ/STHBrhjFbGTEm+O4G/EmVeQ8N+1AstOYeFPp2phYwpQ8uJLMFBn6eSmeuUjMnfQuBnOtiIm7LYvQ2D5fDFeqjKpyjPciNix0/MyYUskuTNvX1y7femmbN6589mXlPE4lJr5atxFpbTCJsbWY9z+0iczpa8aGhux7cvT3lsRgvu9EWp/Kyt8cI7PIPjFFtyJINhKzl/G9F0jKPV9GzLKvjpj7nzS20v6grFzSJlI7Y975FIP0zgnpOcMk9X1QPkLfC1DFvjSGCfNATUiVTJv2B0yb9ofW/2b2VBdCCCGEEELI2CBTY/mVaQ6GhoYwMDCA8wFMaX2mf4cS0qA5AJYkyk8tO1Zkmt91uvqr2+0MKefSvahMqU+mrb9+x7nJU1Zb3dbLl+Oa5593lvPK1L/5M7/NM8rkV84GsFTQ1Sczll7abKidlikzhZA5plPUZvOySxO++Y+dY2XpOhbGpKxyVa1B3SqXUtZcfyRLc9l+yNplKxsi08VY7NsY+wlZA8eqHZQl0ywXu9frhcyxunZJZWP2FWPBDlLwzbGxshcerzIn4tx8FsACAM1mE/39/fLFahzSbDZVq++CjizL2kf+2cLWv/V6vePQr63Vah2HWTb2cJWz6Rda1tfmha2/U/XVdTPrcZ3LdW00Gu2jSP9UWdZVLkT3ojJDxt1W1mWXITKlcrZ6Q9ros4OyxiR0bko2C8A634vOk7LswFyPpLJmO6UjRte+vr72UbSNVdhBWbZn66cQO3DdM2xjIo1nbruDrb9j25nSr1I7JV3Hwjwpyw7Ma6V7fOw6G6JvVfuKmHt16niaNhtzL9JlltXOsWB70n0zdD2vUteQ9chWNmRsx9L+ILSsb38QKlNa6326ht7jY2zPLFdVOyWZsbbuklnlvSjVfprNpvfZlC8lI4QQQgghhBBCEuADNSGEEEIIIYQQkgAfqAkhhBBCCCGEkAQm5Fu+s4iX9UivwjfLZUIqDklmTKqJsjDbkSW+Xl+61ldPajqZmPGrilCZMbqadqDbXlnpUUydTH2kstY0GQFpxaoaL6neIjL0vtXTAdVqtZ7YrH6tlALNvFaSYZaLYeXKlUnlfH2QugaZ9erpwmJ0jbFhqZxkI2a7QuaxQny6D31uSulupHtNzH2orLlX5loRak9m/0jp+HLbyoaH0ajXk/WTxsSVKsyVHiwU8x4ipcOMGU9bP6vW32bqPr3drhR7WWSf6vuuzEjRFLzmWGRKY2TK1K8157TUf2Wl1DOJWUuDUn4FpHNNTU9k6qffc32Udc9o297IiJgm0mU/trkZs9ablGUXVaSJMtcRVyqxovrE2J6OtHb5Ur9VDX+hJoQQQgghhBBCEuADNSGEEEIIIYQQksCEdPkOcoU03KCL1mue012hctenENc+p7uFUqPcGbrhOh6D6bqmE+P+KV1rktpmnx1ILjmmm3BoOcnFs0zXMKlPdPvyyWy79ykljklZbjWSa5/zWkNX828feR+o1t8xLqm6vj6bTbXTXszpslz7pPMx/WOek1xZ9TUoZn037SfITdKhXzfQ56YUthRDkTABvb8kF/mYeeJbo0PbGRP2ot+rTTuLcSesytVQ7wfTHVVaz2PuUyauflZKjeqjkPA62xWpcyrG1k339BiX+FAXVB+Se3FqmJC+H6nX66PGttfuxa71oMpV09W3Npkh7cpDHMoi9R5rErOPdpUzr42xl5g9m0mRcFIXMffqKp4r+As1IYQQQgghhBCSAB+oCSGEEEIIIYSQBPhATQghhBBCCCGEJDAhY6hjqCr+LTUuQkqbU1bMTVWYKTVSZUoppIrE+en4Ym6lfjfjbnVSX9tvljMpKyavijQwPkJjVaRUb0B4/HdMPJ6ZJicmDtGaZiVApyLpP7RKouLIY2KdupFqIjXuEOjsE1cKm5CYNykeNTTWSqpT1ye2bGpKq2AZASmIQsuZOqTG7pnnY96L4Fo/bWlyUuNupZhbHyGpDEPesWLrk5ByvrhISb/U952YY50ah1wkTY5+fZHxS33/Q8x90xcL7ULaj5RJzD1MulZ6105Z74MI1a0qGUWIuVcXWWt19DGJQdqzdatfpXj0mP4pY9/DX6gJIYQQQgghhJAEMjXWvp4JYGhoCAMDAzgfwJTEOuYAWFJhWf27j7yDq5ZZZrleyMzLmb+ThBjoWOmfEN1DypkUtSFb38b061gYk5BvP2Nl5nXOVgpLfW8WN/5f1pik0Ku5mULZ64GOa7Si7aD172wAS4V6Jcb7mIT8ojFWbdZlI7MLykz5xWW820FZ5bqxXobel8bDXqboGjRW7cDEbKdOlfuKImVL38tof48Fm9XHZLytQVXvaZ8FsABAs9lEf3+/XLkahzSbTdVqf/SRZZnKskwtbP2dUsfCgGtqtVr7iCnn01c/ytK1rLIxfWtrRy6vXq93HK5ytrJltTGkn21l9XHXxz62nKueou306RZSLrasOWa+vnWVazQa7UOyg5h5ktc32KpfKiuNidTGIjbrqiO2nUXXvW6uIz7bc60NZjtj+jave7AlL3U8i6zR3VjbJTvQ51ej0Yiyn7L6J3WeuNbNwYK25+qP2HFJvZ9UZQcxthczJrY5VfY9TBr3bvRtzD0s5r6Zr2mDrb97YQfSkWoHrjEbRLF9RWo7x8J9U2pzWTKldprnylovY+9hRcaz23vaZrPpfTYd1zHUWZa1v0EO9X9XnjhNlRgrU9W1Kdf5ZBapJybfaBYYT2XG1JSV89FE16Et0xGvlConNQ6jrFyEgKx7jJx6vd7uH7POGHsK7UtfDFloDJwpT4rTkvLOmsTYZZH1ILRcjI3mMrKEfJFjDSlOsOi8VRg9zjFxkFWt0dJ7JWKQ7n9S3mW9zUqpUX1i1quTaTGBRdYKaRxcY6KQOBdbfVMk7tZar0QP52bqOpMaI1yE0HdpmBR5D4iOOZZSju+Ydb9bsdCp6G0x79Umkv4x7wxIRVovpTExy5Wln7ReBq0NCcTM6fz/sSuPaQfSfaAqpDGS1n4pZ3Wq7oyhJoQQQgghhBBCEuADNSGEEEIIIYQQksC4dvlWBVIzheBy07C9Wl5yM3W5V9ioyv1D1yfGnWittdbq+P+LL74YXDa0nTEuQD73PSn9lH6t6V6lp0cB0lNsVOVW1nbZ7UJKo5zh4eEg97PUEAbA7laa24E0lkVcsaQ0C6nE9IEU4lDV/O8GRexAJyYEpAhV3Dtc8zYn1V081bU1Jg2TiVRWOldWij1Tt1SZMSEgM2fOBABMefRRzNx4Yzz00EPtc8HroCWULCUkbTwQY8/6PbcqmSb6WiK5eALhfR+0R7HYgEkvxlpKL+dDb0+Me7qzH5SK2neZ80tym3alM7W1MzTtUpHxSr2HdctGpP6R7Ni0g9T9i28ulhWyKlFGvfyFmhBCCCGEEEIISYAP1IQQQgghhBBCSAJ8oCaEEEIIIYQQQhIY1zHUOlXERbpiQ2ye9tJr8WPwpd9JJTUNw8qVK0uR362UX6Gv0Jfi3YqQanu+uEMprUFqvElK3K9Nv9SYabOsL15J/8xZTxffqRAT02lL12B7Z0Dw/I9sZ1mpSsqaK6n9U6bMslOiZCMj3vdlSHMz9JztvE6IXcbGp0vxi85rLWV96DGVMfceKVWXL555m22Ox9DQLPT334iNN74eALB2s4mXvexleOCBB4J1SCXmnQpVpOPUdQitJ9dVsveY+Sa9e6DIPNXXkph0Vyap78Sp6v6r4+ufkL2xTbKUesqcX6mpw8yYaalPpJR/oftCmx3YUriG1qsTs36HnAtZD6R5knLPCNlfWmW0xkPqA2k9KOv9KyYx9ej2nrq/nTAP1IQQQggh4czDvff+F4BVeOyxd6LR+BQ22ODaXitFCCFknEGXb0IIIYSsgewPYBVW/7awCkNDr+6xPoQQQsYjE+YX6hh3IgBBrmsxhKTNCnGzk9wiynJZ7EZqpyKuayZlud246lRKJafJKstVpcxUADa3u3xMbKkvciQXryJpcqLdnUpOOZKSZsUmpyqZknyzntwlNhseRj3CZbEspD6Q7KdIvanrlc/VN3StCE09FWIdqXKi3M40t2lzXSvLnV4aE2ncfetl6jqc6nYLXAngo8gfqh955Hz84x9/xAql8Mc//rHjyhj7TpknRcekyByKnVMKo91uTR1i9mSpLrIxoRGuNF45kmt0zLi01wPPnPWdLyuMMXW9jFm/pb4sKyzAJNWdXnJPL2v+xYTIuM6FhITp/8/XlWx4GPV6vbL9gL5+tZ9tWu0s6x4WUzZ1nhTZr7iYMA/UhBBCCCHhLAIwH8BcAIuRZZf0Vh1CCCHjEj5QE0IIIWQNZVHrAIDyXlBJCCFkzSFTZfqadomhoSEMDAzgfABTEuuYA2BJhWVtt+XZAJZCdg00y+XXzmmVtZ2TsOnqkhFSViKvN6SdZcgro+xEl2mOiY45Pja7SLF13WZ9thdaLpSiYxI6N8qUqeOTn7uSzVaqtPUghKrtwKb7WBmTqsuWXS7ElX28z5Oqy1Z534yZJyGUPTdjZFZlB3q9pq62c1XLjKUMm41t51iZJ0CY7mXuaUPptsxe7vVSHuyqfLaRZBYZk9R5Erp2PQtgAYBms4n+/n65cjUOaTabCoDKskzVajVVq9VUqz/an+uHfi4/Flo+A6Dq9Xr7sJ2XyupHo9FoH2Y5Uz+frnnZvK35oevq0temq1lPajtd8kP6J7Vfyy6blwvtE338bDLNPrGNrU2mT09JZmr/+Npcq9XUYOtf007LsB9TB72N0lzwtTN0ToXoatPPNZ7dsNlcl8GCMl1j6RrPEF1964G07pXZr1XYgXSkzs0Ye7e1xdWvUrmic8zVxtB7mK9dMfaTugbF7A9i7ScvK92bffMk5r6gl5Nkuua422bnKeC/FTBPnXbaae3DNyahMsuam761K2ZuxvWPPFdd8ytUV9O+i+xpU/tWmje+cq457dsnSnO8rP1B7Fi6ZHZrTELniWQ/pr3Frwf2Ix/Twdbfqe0ssh6krpexR7PZ9D6b8i3fhBBCCCEEwDwAgwCOBTCIO+7Ytsf6EELI2IcP1IQQQgghBGYqsQcemNljfQghZOzDB2pCCCGEEILVqcRWP0wDDWyxxYM91ocQQsY+4/ot30qpl/KgaS9iMfOL6bnJzDxlUk66LCLHsHltTD5NqV4dU3eznVZ9LHnwfLna9LJB140h9D6R8sqZ+ZnLyn8Yc21KzrxseDhqXGLku+wps+QXVLaciwEyJR1i7Ml5rbYm5Jhz3Ja30GUHRfJSpuDrSz2PcBFixkgiJgdkWTLLQtJdWkeK2LurnK+OsvouRqaElMNT6h9f31nrceRyLaPfy7xWR7r3+PKdRucNbvVPal7s0XSmEjvvvEXOK2P2RKn6mO3U6y1zzZGulXK7u+qx1afrK+VgVpb7WK9J7csiY+DayygjB7rvnt8+X2KfJtmwpWyR5wzp2rL2nqZM/f/5mqPgX9fMetp78OHhqHzyJlXMk9A9tMm4fqAmhBBCCCFloqcSI4QQ4oMu34QQQgghhBBCSAIT5hdq3cXDdD1IdReoyjVMck+JccUw2+lyU4x1iQi93nR90t2S6/W61wUkx+d+HeNuleqim+qS43QtspSV+tWsxxVCEDIyoXIkN+78/6p1namfTllu0VW5wEquoroLta8dkoue5BZlXpvbczY8jEa9LoakVIVkBzHuTqmuY/qcBoCVK1eOvs7h6htKERtKPVeWO7iPer0etM4WcUu02oHDvTj0HuZzzbTNqawlUwrPkpDc083zoXUCcetBWSEyOmb/SGtOETvU22naQarLd5E+SHUXL1JvFfO42+FEvUJqZ2iIkw1pH2b+X9o36vNf2hP5bCB1nsTcp0LDKGx1BoXUWcqVFWpjoruL+2RKxOyrQ20xtY38hZoQQgghhBBCCEmAD9SEEEIIIYQQQkgCfKAmhBBCCCGEEEISGPcx1Lnfe0zsUyodqYsK4Iu7TcUWUxKSFio1nskVmxbyCn0dXxxrlSnIQmJnQ+pxYY2rCTjniiPPhodhRsKExJCE2IHrnFIqKn7RjIGtQtcYYuKyJGJiQ6V26vHwMbZtUla6MpOy1iMpFlpqt5QexadfFTGTwet1gMzQVC8+Gx0ZGSm8dpkyzX52zfEy40lD7FC1/o65h2mVjDrni6muGrP/zHcqhK4JZd3DfLhiM312EDrHU+XHlk2Kpyz4HgcJ13tJ8vuf1G7dpvX0Q3XjnRy2st1AWudi1uhQiqS7jJn/Uruk/VNZhN77fGkGY+ZCDH19fe2/9feimPJNiugjvQOjqnS4LvgLNSGEEEIIIYQQkkCmxlr2+ACGhoYwMDCA8wFMSaxjDoAlkWXy76ZmJ5TVZY76hTGirITtO/rZAJYGyoiV6WpHSt8WKTeWZep9ZPaP7Zyznta3j7OVitJXt9kUO6jaZnWK6pois2i5NUXmeNK1bJmhtl9UZsx6UESeS6aJTQeXzBDde2UHS81fr81fbhJllnX/09f2pQm/ho6VeTLWZS41PouZY1XMTdfci73/8b45dmWOVV2r2rvXtLV2JHAdG4tzU+dZAAsANJtN9Pf3yxercUiz2VQAVJZlqlarqVqtplp92f5cP/Rz+bGw9W+9Xu84bNe6ykpHrpeum6ucqa9N9xCZobqG9E9eVm9HaD/bZIb0c0j/mPrkny9sXZfaP1I7Y/rHpV8ZY5lStqz+CbWZIrqa5VLnZky5mP5x2UjRdrrsxTc3u2E/vnIxczO0nfk1g62/U/WV5qLvvpAqsyzbC1mPXPOkCvsxdQ25Z6XITF3by5qbRddLl0xpnsToWtb9pOgc6+Y9LLV/fH0Usx6UtY7o9Zx11lkdR1X904v7SVkypbHU+zJ03S1zPSjrflLWnt+c06H70qqeM6oq26s9f7PZ9D6bjvsYakIIIYQQQsYTf/nLTNx11wxst90jvVaFEFIQPlATQgghhBDSJf7yl5k488wDUauN4IordgYwD8CiXqtFCEmELyUjhBBCCCGkS9x11wzUaiMYGamhVhsBMLfXKhFCCjCuf6FWSrVf4JGFvKa/szCyLBv1mnWpnhj017X70gFJcrLEFEQSvnK6TOm182b6ETNNhq5vTGoCKa2JpHtZ41VmOSk1Vlm2JqHX65Nh9vvIyAhcKRgkJJuVbNiUIck0dW3XPzzstTVXagellGh7MTYSM1fLGvsYewpdL2N086VACk0L5UsHFJrqKWm8WjbrSmljyvCdC13LzH42dZfSikj3sBhC52ZVaxUQl3pGWltTMduZOhdi1rlUTJuNWS9TdYiRKfWB774QOneLpNuJ6YOY8avVatbUVyZXXHECgEEAqzAy0gCwOFgfibL2iVK9vj22fj5PC5ej7xN9Kewk3fWxNuWn2kXM2jnW1oO8HoXOZ6OiSGkjY2RIYxIzXmX1nSlDt0X9XIyMcf1ATQghhBBCyPhiEYD5WP3L9GLQ3ZuQ8Q0fqAkhhBBCCOkqi8AHaUImBoyhJoQQQgghhBBCEpgwv1CH+rnnsQxZKwYoNXbHh+6Pn8eFuGICdaRYgipj13RC5Zgx075YcZ2YuPYqyMcnGx5GvV6PimuPITQWpAhlxbi4+j1Wz5i4aClmSeo7p66Wz8z+0eOmzZhAyfaKxOvZ6rHF2ZUVm+Yjdr10xUzGxJiWNa/LWqN1zDGoSldp3ZNiTGPW0tS4X+na3Nay4WE06nUxbtvZ5pLvX92I666iL03Me5Het6HxsLbPpXeY5OfyeMsqiInlld5ZEPK+hbL1MYl9l4Rrr9eNPZzZl6lr2e67744nntgHQ0OvQX//Tbj77q+OkuHa6+k6SPelbrw7xiQ1nrlb+2+T0DWoPSbDw9b4/dT1MugeZqGqeHRJTsq6m1PGPX/CPFATQgghhBBCivHEE/vg7ru/AmAVli1bAOAu0D2dEDd0+SaEEEIIIYQAAIaGXgNgFVb/7rYKTOtFiMwa8Qu1zdWhqPu1D6vbliWNkKmfJENP9wN0uq6a+ubuDLVVq9DXaIy61lXOp4OOyy0xpG/1Nuftqq1ahYZH1yJuW9Z0Oy23/8JpRBL0ScXnShPq7lTEPSYmFCE0XVJMSpYYmy0rBUN0CIPjvJTeIqZdkitdTD0xbqUxblIxISAxhNqTiTRGZaVASV1LfSmaYtaZmDmm1yulIGuHLbXc4SV3wiLpkmLmY+haVmSNLstmJV2l+2aR+4nU72XUWSTNoGRrppyxRi/u+TGUFba0bNn5ABbgpYfqxaPKFXVtl/YVpr7tcE1LaESM/CLjZQvlNPWzyYjZy5jtDF2D9NDSWPdl/b7gsxHruqJGp5uMmdPdcg/XMfVL3VforBEP1IQQQgghhJAQmNaLkBgyNda+XgtgaGgIAwMDOB/AlMQ65gBY4rnG/M4k76iQsqkypbI3mL8Im79i6H+3rt1NKdyQZaOudZUDut/OWoSuRWR2tLMlc7ZSWJr4C3Wv7MAs6xq/MmTm5UJkhJSNKSfRa5sto2zqWIbIrKp/Yuwgv3Y2gKWeayWZrnol+b2yg6XGZ2XZe5nl9LLS7wJlriOuskXWrrFsB92U2UtdU+8L3ZwnRcqOxzGRGGv3zZg9bU7q/SSXWZa9V7WXySn7vhlatsjcjO2fMmTGEns/eRar/TSazSb6+/vlytU4pNlsqlabk4+FAdfUarWOI6asfmRZprIsUwu1v/UjVN++vr6OQ9I3v2ZRllmvLaOdrnbE9k+MrkVk6m1sNBqq0WiowSxTjUYj2YZSx7KI3ZoyXeNnk5mqa71e7zhC6snLSrrZ5kPexipstltjEnLY2hkyliH6xvRPiA277CBEh8HW32WNSWr/SGMRYwdS2dDxs+kqjYFNpq2cb96YtqfrKo1tzNyU+se3dsWMSagd9GKNlvrENyZlzZMQ2y8qM2Y9kOZJzBqUOiZl2UE3dK2qXLfum6H7g5g9bW5jgy27ix2TMtop2XoZ+1JbO7uxdunrQcw9zFxHYteCXF/feiD1bVn942tzs9n0PptOSJfvmDi/TIiHqSr9hzK/hQuM7ZNipgF7XOuIUt50OqnxAmY7JCRd83aNYHQbi8iUypoxgb1AGncTXXezD2L6JLX/YvpIip0NjeHy6VnW3Cwrzje1X5URO1tWzGbM+yGKzClXnUXIjLgsU7+y+ii03WXF6wPhabOqSOmxWlTnOqL/Xxo/s5zZDil2zlWP7f8xVJE+TSLGDmKuldZ2CTOVWUx6ova6FxD7KFGWXUr7MGk9SO3nMpF0L6teqU7feinpVtae1ifHhW+/Z43Phj8+N/VdFr5yqXHbUmpTU4a59sfep0JSmUlx0TH3MDPln7QGOfe7xn3I1MdZTxfftRMK3/JNCCGEEEIIIYQkwAdqQgghhBBCCCEkAT5QE0IIIYQQQgghCUzIGOqYuJ6Y+JfU2BhfnEFqvVXEZQGdMQplxfJJupr944yPxei25HFktnzbZcXr5jJyfDHpvnpCYt5MpFinGBuW4iTLjt9VljqryhtcdA7ZdC1CakxgVZi2p8/jGPkpMUixfeuL1w3Vt6x5W5VdSO2IWWfLsp+QmGBXfJ6ub8x4dWOe+N5ZElpvjB1I9zCT1Hbl9qyQbts5ur5VxQTH4JonRd45UVa7ir7HZXAQuPJK4Iwz5kNKRdWNfq8i3tusV9pDJr3vKGA9iLGL1PzDZpslu4yp18wnHbp2+PYyQXnhLX1qjpFOzBpU1rNVzLNNzHsu9H5Ofc6ZkA/UhBBCCCGEjBUGB4FDDgFWP6MMYnWeZ+Z3JmQiQJdvQgghhBBCKuTKK1c/TK/+AWwVgLm9VYgQUhpr3C/UptuI9Mr6IikhdHcC0y0iNeWIieTSaLroSW4SManDqsB0cTGR3DrMlFuS+47ezvxvlwujfq3pyqLbkM/lxFZPioteW1+LvLJcdiWkVA5luV/HuHSV5b5nyjTbGTpOZrmqwjFCMfunrY9SXhuQ1kBp7SjdfbCgq29qSEWVtieFnVQRjiGlKoltZ6icssKofPMk1VWzFy7MIWE4tnu1cx5bSOl3hdHp0yRMXU2Z+noRktYzRFdpbvpchmPu1RIx61ytVmv3j6nP4CBwxhn5Q3UDwFXtuqV6pXaa86SsUJcYUue42T9SeqnUPayPslJl2uwyD2N02qWlHp+cUKQ+iUknJT2TSKFARcakrP2d1M4qnm34CzUhhBBCCCEVMn8+sHAh8O//DgCHIMvo7k3IRIEP1IQQQgghhFTM/PnAf/83+DBNyASDD9SEEEIIIYQQQkgCEyaGWnq1uxRvIl0blNLDUVdoDKV5rRTz5qvHVmf+Cv2YeDhJRlCMcoFUNzZiYuWkMdKRYv7MeqRzvnil0BhFX6ycPp4x8S8mUl9KcVpF3idQaZxtQL1Seov2Zy2bDUrbYZFp9mVZ7ZTGJGZOm+uBbgdJ8YyWa8uOa8/HxBcvFyozNKazqpg2H6npgCSKpCoJXUvNa6VYcB9WOQ47CO2jIuulhDk323Y7PDzqfi2tgdK9uqz3gJiU9R4Hab10zltLPHPq3OzWXI1ZV5RS7dj01DqB8DQ+5r6rrJjpsuZNyn0qlphxDn1W0K91xULrSKneyoprL/J+CmkN0mOhfTJ1pFRdRdPLlYF1TYx8f0iMLvyFmhBCCCGEEEIISSBTvXjlZUGGhoYwMDCA8wFMaX0mfQdma+AcAEsS5aeWLVum2eZutFOX6TKcsvunCpl5nbMBLBXqlZgDYGnCr3KpY9mWGXitTabUlzYdxuo8cfVXSlmguB2MxXZKMkPtoKi8lLJlzc2xsF7GlAtZ58qQl1I2ZkyqstkUiq6XEqPWkda9YLZSXWlnVfOkFzJT52bMfbOba3Rebv68ec5yg4vsMdQTbX851tcDHde9MNbezXIoaZ8YQko5Xd+xYHtjqdyzABYAaDab6O/vly9W45Bms6kAqCzLVK1WU7VaTaGVAQJA+zPbufxY2Po3y7KOQ7/GdW6hpT6pHqmcqa/tfF42RIZZ52Dr79ByZlnftTHtdPVXarkiZcuyA/OcedTr9fZhyjTttAo7yK/Jy8X2bYjN+sYkxvZCx7JI/9jGyTWWMX2b2s6YcmXJTOlX2+e6fbts2FY2xPZDdDXL6v0TYt8h80Rvoz6PbWWL9G1ZYxlSj2vd04/UMZFkhq5zIbpKY6vfw3xrtM2e8vtmjO2l9lFfX5/q6+tTi7JM9fX1idem3vtOOOEEddhh56o5c/6gDjvs3GTbK3o/cekbsx6EjmXIXEnp2xCZeblLL72049CJ0TVGZsoRUrbRaLSPIjJ7dQ9LKRtj72WUs+mq93vM2uW7b7nKVjUmMetBqkxpHcnXklR5zWbT+2w6YWKoCSGEEEJIJ3ffvT0uvPBfkWXDWLJkLwA/B8C3TBNCSFkwhpoQQgghZILy4INbIsuGoVQdWTYMYG6vVSKEkAkFH6gJIYQQQiYoM2fe336YVqoOYHGvVSKEkAnFuHb5Vlr6hSzw1fyZkWJAJb6TzScvC3hFfU5oqoBUXX1lzbbor8LvBuaYmCgjBUFhOZZ6pHpTz5nnzXYGpUtLkOm6NkZXE8lmpdROIXJTkGSa8nz66eWqGoey6ilrLuiYbY6p15XexkfQelRy2qzQc+Z1vpRxuT6ZUoVSzehyq0r1JMkM0SckRZNUp68dZa3R+f9tJUL0UwG6ljUmK1euXF2f9reL1Dl/4YVHAPg5lJqL1Q/Tne7eofWWdT8xSU355VuvpXRAUr1Frsu01DwHH3xwkowYmTF72iLrSmrqTOn+Yks5pqPr51uDQunW2qpT5B4bmmLLt3aFrK0Ko/unrHGvCl2O2W4phWORMXExrh+oCSGEEEKIj0Vg3DQhhFQDXb4JIYQQQgghhJAE+EBNCCGEEEIIIYQkMGFcviU/+hh0n3upnqA4GvPvVozLjBkzOq79+9//nqCpjBlPYcaR2q6NxReD0Gi8ZF6hcbWxcQwxcTW2uN9seBj1en2UfqExgT5c+sTEB3boUzDOQ7dv3/jpukv9GhNjo9sEIMcHSfFVpkx9PE1M3fv6+tp/mzGLMfFn7Wu1dzm4ri0rTku3g5i+lIix77LaJcnUx7JWq4n2FSO/ipgpXQdb7FqqTGktBeSxlmJMpXj0kBhl1fo79L0Esej1xtiz1D9VvMMB6H0spu/dAjEx+dHxjgnvoNHv1T67DK3XV0+73UoVvneG6pBlGTLLe1KATvsua87o73DwvXOirL1x+91FrX2XNH4x71SIeV9GKlKcbWo7TNq27riHxewvU98ZIl0r1VmWXVa1p03d87dlBqxdqft//kJNCCGEEEIIIYQkwAdqQgghhBBCCCEkgQnj8h2Kz4VDSmUUk65Bv3bvvfcGAEy7/XbsteOOOO6447B06aa49dbp2Gmnf+KrX923fa3kbhGTqst0ddDr9aUqCE014XOFkFIZpeJyXQtJc2LTTaGYi4vP9THGRU8ipv/0enXXI5treyiSzTjbZXGtiXHjlMbTldrBlvbBrEfXISZlm6SPK/VcLDHrSkwqPK0QsixLdq2VKOJSrY+Zb27GuDRL50LDe4oQ0wf6mEjrd5nyU9MlVZFCB7Dfp1xupTqpoSO2/4cSsz6VZV9SGsYirr562Zg0gzH3Bf1eHeOuLuFrV24XIbWlrgc2e3LtR8qaN7axzWVWla5I2kNKMqV7Y0pqtZC9Xow9pYYNSek5zXtYWeFGVYWvSPNfcss316DUNeeb3/wm/vrXLXD33ZvhFa/4O/7nf+Y7r5Xs3bcP08MxqujLNe6BeiywdOmm+NKX9kStNoJLL90WtdrByLJLeq0WIYQQQgghhHSFv/51C3zvewejVhvB4sW7ApiHLBt/Kf4yVdVXHhUyNDSEgYEBnA9gSusz/XuJkAbNAbAkUX5s2WnTpgEAdnjqKdyx3nr4UeObOOext2MYDdSxCgfjGzgGHwPg1j1Epq0PbOXM7xJNmfn52QEybaT2bWwbAbmdZcmUyi516FOlzJiy+lguRZh+Nnk+m5HKxlLUDsb6mJQls0g7Y1+6UbUdhK5doYxVmVK5sXwP64XMomtXLrMX60E3ZZY9JiFzfKzeF4qULXM9GE+6ppQ156aJslxrnhurfZtartdjUrRcXrbQviKyXF72Pzf4MX68fEH7megg7ZnIJ1Mn5Nkm9n7yLIAFAJrNJvr7++WL1Tik2WyqVn+0j1qt1j7Mc7ZjYcA1WZZ1HHpZ85zrWgBq7733Vnvvvbe6Zto0tffee6tPfepaBShVqw23/j1E1et1Va/XRX19Mm19YGunfp2tv/LPBwP6SOpbV38UGROX7iFlY2SG6L4QaI+ba/xc9mOzrxB7irXbXK/Blq6p/WP2u9Q/+ee5zZY1JqF24LNvW/+65leovqnlQnRz2YFke67yua6NRqN9FLEDSWbqeKbaerdkFrFbqZw+liF20EtdU8v65ontfjbYGqvQ+60pU1q7XGWLttO3BpUh07fOhvaP+ZnvnqaXi7kvSDK7MSa+a7qxr0gtG7PXS50nMTqac1OygyJ7tjL2QLFlpf6R+tI2Z1xjUpbM1LGM2VdIuptrUOyal8t83/sWKWjPRMD84PUgxNZ0u81tNtbums2m99l0wrh8V5X6KbScKV9P43HttdcCAFYohWuvvRZ/+MNeAOZhZGQugMUYGXnJtUHSx9QtJk4rE36RMlOOpPalGfOmyywSp5xFxGVIWGMUHbGzoZjtihkTZYtFcZBpsSo+9HrNWB4pTkyKnUuNKQudTzbMvtSJTpWg4dJJeWwhZm7GIM1NSZ/UtH5KqeCYU1NGVbHG1ndXBMQ6xfR7zNyMiacMfeeED2mNlGJVJRvx9U9qGh+pL2PmiXmtba1XsMeGSm3Tbagqm01dL11tDkkDo+Nbf1LXJOk9IOY7Ocw+ePHFF4NkpO67dB1s5Zz2ZYn39qVsqpqYPvC1M7XeGGzpJl1zM1S+T1fp3ihRVf9I10rrp2/vrlOVXYb2Zcx9wFyDpHZJfP/7hyDL5mFkZD9k2VVQatC51ZX2B76+GhkZadusRGqfT5gH6vHHotZBCCGEEEIIIWseWbaoHTc9/gKRV8O0WYQQQgghhBBCSAIT5hfqslxDQl39fC4DuttE26WrZBfGILcyi0xXyiFTB4XR7uCSq6iU1qAqN5vVbZuH72MugMUABp3XSuk/JEy3tvx6m4unNCZ5PbYUVjH9EZrWxIakn819PXdDNG2milRLputjjJubq86YcrZrU9cVSQdzburEpLSrys3cel3A2uVbV0KJceGKcT2WyvrWK+mcvu5VRYxLZUwIS1lpfCR9JGJcIWPmZjfcd8tKZabfb6tyTy+CFEIkuexL7tdF1uiUNEdZgOt/qa61jvChmHSFqfeepDRQAfVL+pr62dzDU6hiPpQ1zqkhl75rJYrs/ULRxw4YPe5luYuH1ild6wvTs65Bjr1MGWk0+Qs1GdcoNQ/AQlyKYwEsBDCvxxoRQgghhBBC1hT4QE3GOfsDWIURNACsAjC3t+oQQgghhBBC1hj4QE3GOVcCaKCGVVgdwbC4t+oQQgghhBBC1hgmTAx1TGwf4I7TDI1LTtFHOT4vw3dfkh/TRhMpbkaKLTbTf1QV03bIIRn+8Y/PY+tbN8R9Oz2OpUsvQZ7eXZIpxTObmOfMdodixp/pBKePUKqSuBkboSkGiiDNk9TUFz5bi4lN0+emK0WaLZZeiieWdPXpo8dbSvjsSZLjGu+QlBShxMSYx+gqpcmJmcfdmmOhpKYyqQpTH/1dGzGp1lLTrBQhNf7bdb/Lkdqp90/M+ydiYo1j4s9jbETS3fy/7Z0YNpndihUv6/0GMXu09hpt6eOYsU+dxzFxtjH3WOu8cazRejurSjcppfwLur8U1CHo3RUB97AYpLH03TdDdQhNE9lRZ8B7EaqyA4mY94mUsSbxF2oy7tl006U4rv9kbLrp0l6rQgghhBBCCFmD4AM1IYQQQgghhBCSAB+oCSGEEEIIIYSQBCZMDLUU42Lzjc9jQyUfezMWRcpxKuWZ88UK6NfG5LYzCcoBidG5pVPzBDrzOsOv91577dX++9prr02SDwCDg6vzTv+bUhgcHAyOxZDimWPKFonHqSJ2vipiciyafSDFOrnK2foxNPbZl8tZiteV4s9i8g9LMV3S3PTlqwx9j0NMPFM38ln7ro2JdQrNP+yb10HxaD2iyH0ghtR44tD7nY/Qd5YUiQk0SS0Xc58w+0ePKS2SSzYm93ZZcYm67vp7I8z3pJgyi8yh0PjYmDhNE+laXzu7gRQTb92LOuaJ3pdOG7G9y0ToO9+9OtX2YsZPGhPpHTQx8tt5zC12INl3N94fZBKTn9lk9913BwCsf9ddGHnySfFavV6zndE5oVef8OoXOudD56myvGOFMdSEEEIIIYQQQkiPyFS3vj4pkaGhIQwMDOB8AFNan+nfi4Q0aA6AJZ5rzO9a8nptZV3XVikzBFu5mvnrgsMEypRpMm399dt/r3jiiULyipTtpcxYmy1DZrfK6WWrmJtSWfPVdDEyUzwOyuzbkHUkRGY31pGqy67JMsu6n8TILFIuZI6P9zEpq+x4npu57rOxep1N2TzG7oOK9k9K2aLtLPu+aSKtBzF+AePJ9nohU7KDkPEZL/2zfms/vuPTT+Naj8dqr+emWS51fxm613oWwAIAzWYT/f39cuVqHNJsNlWr/e2jVqs5jyzL2ke9Xlf1el0NAqper4+qJ+RYmFBGL2fqlypTb1eWZaXq6iqb95/Ud3k5Xbf999+/41h97TwF/LcC5qssy9TCVpkYHfP6FyKsP1zl9HaF2kWszKrGJLV/fEc3dLX13XiRqfdtEV0l+3HZZVGZof3T19en+vr61KLW32PBZl26lmFDKeUajYZqNBpqMHLtkuzAt66EzmmzXH7PGWz9Hapjt+ygTFsvww5i79N52Zh7fNE9ict+bDaaH6n947OfkDaXKVPa6+lHN9eD0HLdWruk9UHv2xh9TZnSOEj6lrUXjumjInu20HKp66yvnSH3Qtc+2jbu+fGDH/xA/eAHP1AP7rpr6/p8bz4vyg5sfeA6qrJ3SYci8prNpvfZlC7fpEfMAzAI4FgAC6HUvB7rQwghhBBCyJqKvjcfbP2fhMAHatIj9gewCqvfi7cKwNyeakMIIYQQQsiaC/fmqfCBmvSIK/HShG0AWNxTbQghhBBCCFlz4d48lQmTNkt5XuPvui7mJUSZkZ6gjHIm0qvcY2RWlfYhJsWHrt/ixYvNswDmA5iLWu1qZNmlyIZX623K0PvE7AP9Wqk/JN2UUmK7pDGJkSnV6xsffTxj9JMwdfelm3Jd65OXBaZ6ydN7ZMPDqNfrUbYm9U8RdN1N2ytrTkn9E5vSzVanrd7QsnlKvRHY0+tJ61nq3DDtICY1j37ONy+kfpcwZeZphdJXgngd8mtj+1hP9RZjvz470IlZj8y+9N0fUygyF1LnuGRrJmYKx9C11bzHm+jt1FNfxSLp3o30bpLNxtx7xgLSmmPuE2PWMpcMmxzbuZAZIelu6qPrG7ofj5WZStJa70hJ5iJ1nbUhrQeu/lGWtFD6ebOeY445BgBwsVIAbka+N1/9ML3IWY/UP9JeT2+Xbc+W9HxluU7qeyktcqqtTZgHajIeWQRgEbKs7r2SEEIIIYQQUiWLYD5IEz90+SaEEEIIIYQQQhKYML9Qh7oBFnHFCHUrN3XI/85abhGSXKle00VBcuMy25nqmin1pc8tQ9dXclUxXd5M9LI217aqibGTGNesVFegIq7H0lib9TQaDWTDw2jU66NsrSyZOj47kNDtvSqcNlzQFS01rEPCtMNU1/FeoLtQx7qq6mPic7u1rokW1zVz3TX7UndR9yG570lrW+paUcRVVKcsN2mffZflyhpzXaiLtc8OQnUwx6Tt+ugIcXBh7jGcLsSyYlGurLqLsFIq2X22CDHhRjH6hdZbZI0O3T/FzIuY8L5UV1rzWl8YY2rYmXTelKmPlzkXG43ORxv9PhKzJkohopLuuXzX/kkiJvQtxp0+ZKwzyzVl7UlMpD1b6pyKWaOr2BPxF2pCCCGEEEII6WAevo//BtNHER98oCaEEEIIIYSQNqtzMl/aysmsFB+qiRs+UBNCCCGEEEJIm9U5mUeYk5kEMGFiqHViUliVFQ9gYovvyOOZY9Iw6fqacRgp6RF8upr6SPj6To9RiNFVioOoIi2HD2csmiU1QVkyXPEvynJOQkql4IvhXLVqlTOONTXesoo4UR8xqVPKmlMmof1eVh9Uta7FyElN3WeWk2LBUuLEclz6xKYui4nft8bLB6TJSY1jK5LSrhuYsY6p7xcpkj4t9h0PRXHaXYAM177CVy4mXjc0DjHWXnqR9igmnWK37b+slFEx7wVK3TtI+tjSz7rKxergKqeMd2TY9i5WHQJihDtlXgngo6i1HqoHBv6MtdfeCADw6KOPOssVeQ+INK9D+jkkjZ7rnAIwf/78jnODg4NOHWLuxWXF70uErJ9lpxLuqL/0GgkhhBBCCCFk3LIIwHwcjG8AmI+1176s1wqRMUymevG1dEGGhoYwMDCA8wFMSaxjDoAlFZbVv1/JOzgvZ37HFDIAqfrG6qrrU6VMqdxY6x+p7FLPNTbdq7Y9qZzNLnNs/V62rtJvxUXtrkjZsbIehC7GPplF5rSkawx5PbOxep6Eti21nE6I7Y21uakznnQtUnbULy76Lx4lyTTX6CrvJ0XKdnNuSjInku3pa0kv9jIpUGZ8udA9Y9H1YNJaa7U/e+HFF4PLpRBb1rxvmoS28/823rjjs2XCL/F6ubFgBz4yxO8rngWwAECz2UR/f798sRqHNJtN1eqP6CPLMpVlmVrY+juljoUB19Tr9fZhlqvVah1HqL6uc/mRqqtLn4WBMkJkxuiq953ef0XHJLWcqbs+JmbfhYxtSv9IdhDTTkk3m+4uea4+0XW3lQ3pq9Q2hvatpGtZ9i61O2ZMUmUW6duyxiSvY7D1d2o5aUyK2F7qWLrsK7aseS/SD3MNtLWzjHlSha1LZc12NBqNjiPV9iQ78I17qP3E9m0V5aroH/PakPtvL/snxmb1tSSmjyRdy9p3ldnOboxJ6n0zxvZS+yd0jtvWg5j9wcYbb9w+ejEmkq7mfTP1OWP+/PkdR+o8CZ033ZxjKfuR/Gg2m95n03EdQ51lWfsb7rL84aV4Rj23nBmLkRnftOu+/DF55UxURJxBaDmT1Li1GGLqqSpnrjS2Zl8qITZEpyy7k+T7dIghNS92apw9IMeCxdi3fm2R/Lp6PebcrCr/aBVzTOoDaW3wUXbOYxVZp1nOrDd0bpqY11r7KOHdGnk9thyeofqY8lLjfGPR642xb+namLU0Nr7QhXNsA/KRV9G3MeuT+c4AXT/zXhizRqfOkyL33ypyOetjGbuuxbzfILSPfLpnWeZcR6R7Yeo7J2IoYvvWOR4wJqnrSIw+vnKh9ZpzyJwLy5Yta/9d5B4bg2QzNlTruph+/+IXvwgA2PGHP4RSCsuWzcHjj++MDTf8K4DOGOrU9bLIvVpC6h/b+yBc+4oy5tu4fqAmhBBCCCGEEFKMZcvmYOnS/4csG8b99x+C1Y7Vi3qt1riALyUjhBBCCCGEkDWYxx/fGVk2DKXqyLJhMFVYOOP6F2rdrSHU1cjnJiK5TeqvwpfqNTFfgx+algKQ0z5I6XeqchGMdT9JIcmdt+V6pOtnlpNS1pj09fW1/165cmWw7jHocn1t1u2giItVaoom81rdhk37ldIeBbmKBrjdmvVI/SPNE1/qmW7Ye2q90viZbSkSdqLj6nebTImYOV6W62hoP/uu64arXxFbi7HZVPsea/eXmDGpXHfLPUVqV2pohInPtT2VmHtGasrNmPUgJkwhJm2WRIxd5udt14WEjxW1AxP9Xl1FWkZbm0L7yxeGYwvzsu0rYuqJuW+amHt3FzF7GR8p9y1lWYOkej71qU8BALYHcD/OBnAIgFVYHRW8uOPa1D1kFS7WQPo9X1ovU8drXD9QE0IIIYQQQggpyupUYat/mV4MunuHwwdqQgghhBBCCFnjWQQ+SMfDGGpCCCGEEEIIISSBCfMLdVn++FJsqI4ZDyDpU1b8ookvVlQnNe7BJDXNSgwx+plxI6Hxwz5dpbhpPT7Gh5SaRz8Xkz4mKP2Pg9R41Bhbk2LBQuKis4C4I9ccylNGSMSknpEoy967EadtxoqXFTubmsqsG/FTPn30PmjbXkA6DddcsGkSs0aG3nt8VGVDOlIfVRXHKlFWzLlWoXcNytNo5uhreEpsYdnpkqT127T3mPuCRGrarNT33vjuhe29l1IwWxFjM9LewWbvZYxlWWlRq0pDqiPNhRjMGGXbnAqJMfelv9JJiY/3YdpsTIrLXqSqlYiZqxLO+2iF9yurzIC13ZzvwWnX0tQkhBBCCCGEEELWbPhATQghhBBCCCGEJDBhXL5D8b3OPtQVQ0ojBLhdhGLdMNopGDz6+Eh104iRGZPCSsd0eTOJSZsV85r8nNQxEfXxXGu6kVTl9hNDTLuqsCfd1mPbL7kPdcMV2Td+kjtvGfYUS6g7oS+9nLReFtbNITN0DfKNpcv2RhzrUE6M61qqa2ZMasUihNqez801REZICavLcAmpZ3RiQlskQt2UTVzusWWnSyoL3fbKSgdUZCxjwtfy0K0RjLa/1FRdvhCQtju9xZZSU9pJqR+7ZTOS7qEu1bayOqmu4iYx62Wq639VoZup6QJ9qehCn0OklH9mWWnPbxIT/lcVeko7qZ2pc4q/UBNCCCGEEEIIIQnwgZoQQgghhBBCCEkgU7343b0gQ0NDGBgYwPkApiTWMQfAkhLLhjiKzQawFGGubyEyqyxXhky9T6Q259fl/WMS0l/jsX9i0Puom+20jSUwvsYkRPeq7cA2F8bD3Cwqr0jZ8dQ/ZcjUGQs2W2a50LJjbZ5IuMbIV9blQtmr+0nKnsQlM2TejJW5GTPHYmRmKGevJ8kcT/NkIslMvW9Ktpa6jhSR6SurkzpPTKpaD8oq5xrbZwEsANBsNtHf3y9XrsYhzWZTtdqcfCxs/Vur1TqOmLKpMrMs6zgk+fk1sTL1clmWqUaj0T5M+fV6veMIbaer74r2j3T4dNXbVUSm3i697xqNRpS+Zh/VajU12Po8pm/0st3sW5fNpsqUbM+nq1nWdiwU7DJknsTI1MekrP4pazxd+pQ9T4r0bRXzJMb2bPIHLbrEyPTZgTQmtrkQ0saqbK/MtT20rGtOh/ZlGXbr6tvQ/vLZ0HXXXae+/OU71Tve8Yj68pfvLCSzG2NSlu3FzDHJ9mL7J8X2pHKm7r222Zh1VpJZ1pjE2K1rPxdre2XZge++mdKvKeVcZUP6ueg+upvPRGX0bej9Nj+fKq/ZbHqfTde4l5IRQgghhPSCa65ZH5/85Hao1RR+9rNNAcwDsKjXahFCCCkAY6gJIYQQQrrAjTf2o1ZTGBnJsPoHoLm9VokQQkhB+EBNCCGEENIFZs0aaj9Mj4xkABb3WiVCCCEFmTAu31lEfr9QYvIUFiE1n2Um5Icz/y4rv5+kW1ZSjkqpXWbuPzOHdVDOaovuJpJMm/wcU77+fym3rZQzUK8npEdT50KqHcbkzDXr0f+f15MND6Ner4v5mqV+9+UJtZ3LHDmPJfQxkWzW1CFmTKR6i6xPZa2RUrtc65ENWz5rFVDO1++h5yR9YojRN3Vt98mU7LiqPpDyrOv4bDZz5AK16R3Uf5ZrqrYZn91+8pPbA5iHkZG5ABYjyy4BkFV633Re28V80nr/+GyrLBuW7CCmXpdd+uoz26H/3zyXuuaY901zrxeas9p33yzrnqFjrhWmTH1dMduVqo+0BpW1fldFkb2D/n9pjY6xw5j9dwwxObTLWr/LYMI8UBNCCCGEjH0W4aW46bgv8gghhIw96PJNCCGEEEIIIYQkMCF/oS7LVbsqF2/TFUPXV3LFMOmGa1hMX5rus6FuUkXcz2LcyGLqDb02xnUtrzN3CUxxI/PJ0OXEklquiO4uV9+RkRGxXU73tEjXUH1MRkZGRPd1yQ1Rcuc39TXtXdJV0j3GRb8sF0+fHIlUd7kYFz3TBc1VzkSam65rU7CFgNjc5SR3PbOeIvrp9Zr9FXMvCr3W1NuUGRKekaO3syw37pi5KZEaIlPEtlLv4ylzMbdZs48kO4hxv46xPYmy1qcYu5T6VgrZCdXNrCd3hVatv8tyJZf6wLSD1BAn3xxLDVUMDYc0r40JBRwLWO0yIHzNZXuZxVakusz9d6Px0iOlFLLnI8Xt3FbO6jru6B/X3FRKBevOX6gJIYQQQgghhJAEoh+or776asybNw8zZsxAlmW4+OKLO84rpXDiiSdi0003xeTJk3HAAQfgnnvu6bhmxYoVeNe73oX+/n5MnToVxxxzDJ5++ulCDSGEEEIIIYQQQrpJ9AP1M888g1e96lX49re/bT3/5S9/Gd/4xjfw3e9+F9dffz3WWWcdHHjggXj++efb17zrXe/CbbfdhssvvxyXXHIJrr76arzvfe9LbwUhhBBCCCGEENJlomOo3/jGN+KNb3yj9ZxSCmeccQb+3//7fzjkkEMAAD/+8Y+x8cYb4+KLL8bhhx+OO+64A7/5zW+wdOlS7LbbbgCAb37zm3jTm96Er371q5gxY0ZSQ1LjUSWf+5h6YmLuzHr1uAP9b0CLQwjw4Tf9/vNyZsykqY8pU0pBpOOKDwqJZ3bVUzRGRUrfIsXKSDFmZaUn0tNb1Gq1Dv18MvSYJZPUmDwplh9Y/cXXy3//e7z7da/D1ltv3XHupJNOCpLhwzUmZaZLMtH7Ky+Xx4K50rL5ZEipSkx922NpsQMTyS7MeSvFm5l9GxovWGbMWGjMq88OJP1i3qkgyY9NoZaCmUJHir0sK7ZYu8gb/yrF58XYTEzsrN4HvjR6nWqV/06AMm0/9T0pEr73IpRlw7Y9kes9F90gdY8m1QOU/L6KgHdVSO8BiXnPhVlOeheCuVdo6xDwzgDpfTCpqcxi9mFlvXtkLMRBV5FGs0iftK9BXGpDkyrS85qYdpCaCi51vkuUGkN9//33Y9myZTjggAPanw0MDGD33XfHddddBwC47rrrMHXq1PbDNAAccMABqNVquP766631vvDCCxgaGuo4CCGEEEIIIYSQXlLqW76XLVsGANh44407Pt94443b55YtW4aNNtqoU4lGA9OmTWtfY3L66afjlFNOGfX5+QCmtP7Wf7kL+b5nDoCFls9D6rGWDfj2xykz4Jt3V9mOeiy6zwFwsUe3mvGtUl5LiEwb3S6nl9X7clSrLf3QLmd8I6Vf6ToXq2+u22wA/zs8HCTDPD/bItO0H9s3byE2a9az2e9/j60efxzH/f73mGJ82bXrKAmjCeqfUF0DyoWWtc232QAuHhlx9jsQtx6I9iTYwShdBdv7pTnuQj2jdJXWhNQx8cn0yHCWS/hFofAa1AWZMXYgjknkWOZlffcFl0xruQAdqpwnLnp5L9JJ3ldIaP3qG5PM/LUqQqZrXxE9TyL2MjZs9+pQ6bG2J5XzolTY/LKUy2WOKhs4vy5WavR+QPvbdS5E39T9paRv1Jj47D2AMbOnTX1eiLCDFOZg9T6oo9oAHUrfH0gUaWfC3HwWwILw+tMBoP73f/+3/f9rr71WAVCPPPJIx3WHHXaYevvb366UUurzn/+8esUrXjGqrunTp6szzzzTKuf5559XzWazfTz00EMKLW+T/KjVau3DPGc7Fjo+D6nHVjbLMufhk9loNJxHXoerrEt3vZyug+3o6+vrOHz6pvZtVeX0svV6vX1IY2SW0/vOHHvXuVh9c70GW3+HyDDPDwbYT6jtmXaq9129Xlfvfve71U2bbabe/e53q1NOOaXjKGs8Y+aJpHtMWb2Ner9K/a7PqRCZ5nja+tlmB756dJnmuMeMia0dRcckxg5cfenTNaRcEX27KTPGDmw6uHSVypn3hVA78N1PQuqpcp5UZQdllU3dV4TYRMiYFLmHSeVC54bPDmL6NXavFzImpu0VsYPQfVfMeIbM8byceR/XrzXPxawHqfvLGDuQ9kExusbYQS/Kpd5PYuwgVV/fXrQb+4NQ+0mxvdT+aTab3mfiUn+h3mSTTQAAjz76KDbddNP2548++ih23XXX9jWPPfZYR7lVq1ZhxYoV7fImkyZN+v/Z+/co25Kqzhf/rr13UlpAJl0KFG8ReQk+QE8BPqsa5GkVtPyu17p2tzhKaGnAK3DbHm3f7uGjbdt+oXBpUduf+KLw8bvtyYOIQlEF0gJ1KMGWNwhSPK0rWDu7qi5wTub6/XH22sSeJ2LGnBGx9s7M8/2MscfJPGtFzBkRMx4r95xr4qKLLlJlazk8+1icQSJOxeo7XxNnINHiDsI4stS1gVRslmyjR75Ei1/K9a0V2Xfh77nx0fIGa3ZQmtdVk5HSrcf5Y2XNoR2rvTRuReoqf/+N3/gNPHPx7xOf+ETccstj8bnPfQMuueQvXDFA2r3h71peXq1Oiw4hsXnSIz4Gmg5DDHO3vw/5V1tZLpyrS90Xudq1/tHka3HbJfnR1fsSczqM45bXSmNePXag4ckN7tFvHXjiO8e4Jq/n9jO3PS3Q9k1tvZTUvOciKn9h79re41mDLDnGvfa+LGeIna2x53XsjaX6tJThOSda6omVse6Ffd/bzlqRctpckfXIshqp9xvkbDZ3ztD0C9sp7X0Ta7Tn3BPiWZ+0HN/W9bw3xJmHhOOZy+WsxbXHznOxchLPvR6bTZUdy3aaxlA/8IEPxKWXXorrrrtu+X97e3t4+9vfjsc97nEAgMc97nG49dZbcdNNNy3veeMb34iDgwM85jGPaakOIaQRt9zyWLzrXT+Jj3/86XjXu34SfX/lplUihBBCCCFk47i/ob7tttvw4Q9/ePn7Rz/6UbzrXe/CJZdcgvvf//740R/9Ufybf/Nv8OAHPxgPfOAD8a/+1b/Cve99bzzjGc8AADz84Q/Hk5/8ZDz72c/GK17xCpw5cwbPf/7z8X3f933Fb/gmhIzL5z73Dei6ffT9dPHv5QBObVotQgghhBBCNor7gfod73gHrrjiiuXvL3rRiwAAP/ADP4BXvvKV+LEf+zHcfvvteM5znoNbb70V3/Zt34bXve51+LIv+7Jlmd/+7d/G85//fDz+8Y/HZDLBM5/5TLz0pS9t0Jw8OXcBq0uH1UUXWHUNnU2nLhfd0O3No4N0xUjpFvs9dDnRXPS0elu6VJS61tS4jWh2EPZtiW4lrqyhu5P13nMqthmHm2/+dQDfA+AszkWKXG+u23qfJ+VRTboUDY/r0TCPLa2Lpkjr+6p2aCEfrVwhc/NkjDQZ0g62trZWrmuurOHvOde1Vul3wvUgeS2CdGn2hAmZ9EFdOEZIzg5a7Qse3cNwA80OpT6aa7R0Ky0NO/GMZWmqN1lOrgchyRACg/usaS+MXPesOab+iuiaW+e0uek5H2jhI6Xp+Woo7dt1hK95yIUtxnToEXdp1qgOP1zIC/WVa05p6JakdD2QeNocyvTYgTbf5e+p9SnmZq7pUOoSn6PFecD9QH355ZdnJ+VP/dRP4ad+6qeS91xyySV41ate5RVNCNkQXXcKff90AJcDuAH8dpoQQgghhJDGabMIIceXrjuF4UF6w+9sIoQQQggh5FDQ9KVkhBBCCCGEEELIhcKx/IY6FRO8ci0RO6TFZYTpLXKE9YSxlrFYLy32IowX8FATVxDGU2j9M9ar57XYi1xsijflSCw2Blgdp1bxqMv4oKuuwv7urhqXlWqnRbIlPcKKPkKGpc5WdhBNi1GZLkmLJQQSscaGmEmNsWImk/VG0qN4xsQ61p70MWOlyTlz5kzyWhhHC+ixtJ70LSHW9IQWmSFa3+Z0m0wm0RgyWdbz/gzP+Gn2XmMjnvlnipuOxFpa0grVvsehle17Ygk96ZJknVr8YE3qNSut38dhuV/O67DdNXYZUjSn1rgXecppust12JqyLbeWaunBwt8f8pCHrJT74Ac/qNabQnuHSt/3rv0lpNXeqOnXKu3oWOf61HklFret6VcTY951XfIs0+K9PPyGmhBCCCGEEEIIKYAP1IQQQgghhBBCSAFH3uV76TZQ4DKUS/+Rcgnqcb7rhSbHo1Pqmvd19q2wuJwNlKSBEpVHXTE0t6BhjLr9fUynU7M75tI9Zn8/6y7X2n3vJICnO92ySl3/pRuZx101dI+RjOHqF9p6LA1MqLt2LdfGWAhBl2hn+H9juXhGQ1IK6m2VSiXl/pmrvyZNTihTjp+2ztSk7dLcXNeRksWD7INleETENdQaQiTdAkvd01uijUky9VOGsVLsjYU3deewXtacD2Kuo7FrHjxnB20N0kJbPOl2tBSgMR3GQBvb6pRjlXPTE34kZXjW4dKUrnLtuu6665bXXvGKV+CTn/wm3HLLI3CPe7wHH/zgjyXle1KgyfOlJ02U9ZoHbYw8rtAe9/TcvCmRIa/nZEavNd6LWoQxHvkHakIIIYQQQsiFxyc/+U14y1v+GbpuHx/84FMB/CmY2pOsm65fx5/lGrO3t4ednR1cC+Biw/3h3zqGxl4G4EZHOVn2dKZsrFMtMlOUlh1TptY/69J10OEEzo2J1ZhLy4Vsqp3rtINN2mzKvqBcK5nXQNoOYmuHpGU7rXY45niWrpdjydTsYCyZqfs0+esak4GStat23TuOdtCy3CZkttbV0s+1MuX5ybLuXshjQpnnr12P+5ZvWV77kb94Fn739h/EPmaY4iyehpfiGrw4KlM7u6fscJCp3RvjOIzJJtYDSUuZ3nJ3ALgawHw+x/b2tn5zfwSZz+c9zvVx33Vd33Xd8vfYZzKZLD/D/51U7h8+0+l05TPIOinqjH2Ge0PdLDLlJ5QZ1plrc43MsKwmU7bZI1PWG7bRo+MwNruLn0vLrbNvS8oNfbxbaT/esjEbWFf/yPkXGz95zTuvw36V87bruqh9t25nat3Q+rlWpiajdE57dJXt1MYytc7UytTamdJNW2O8feSZm7IPtDXPMraDvY+hq9Y/OfvWxkTbY1Ofda7RtWUtc9NarmaNtsy3kj0+LJsbS2090NqoyczZythjOdba3mpuesazpn9Kz7Ry7br++uuXn2/7tn/fA33fdWd7oO+BK5Pt1M7t8n55TvTu1ZtcR0rLavtkzXqgyYztb6k9t9WZ1mLf4Wc+n2efTY+8y3cf+YK9VQxQaRqKlnRDrJxIExBeG+hjMQmLOIMwrYGWhkYiZYb15OJmOmO80DI2ZqGrbJfW18MY9fClsyktB6zG1eTQ+sAio6RsaQysZLg/Vy4ZDxeJcTHFQRpiYzzzT4u3HsanX+ii2WmqXosdaBS9e0CkupH15FI9tepbD3Jeh8Ti2rzvRfASXYMiscU5+WOkNtT6Cjg3Rj3ysbOptbSHb5w975yw1DPgSd1X/Y4OA6Xv5MjJ18bEs+ZY91RJbj3Q0ilG5SfWaGs9udhnbfy0PtD61jvHUnjS6Hn33BTWdsXkae0sPVcM5UpSXGpnWm1Pk2vXFVdcIep8C/r+cgA3QHP39qSTqjknrgPtnRMS61k0ZxOlZ1oPljHqDOdEiXambdGWI/9ATQghhBBCCLkw6bpTGB6kj14gKzkOMG0WIYQQQgghhBBSAB+oCSGEEEIIIYSQAo6Ny3fo118SGzZgiT9rjRYHEcaNaOWA1RgPGVejxU17YoI8+QatMQmlcX05PDHmWnyVvBbG1eTisKLXDbEfqTGw9GjYh7l2WsnF/aWu5eL8QhtexsYs4hc9tqbFsVrzR3v7JrSDGrS4Q09MYEy3AS1GuAYth3YYjzrLjGdsfRri1jy2p2GKMV3EpkfnUKKecP1qpaskNV65+mve2xCLI0+NiVUHazx6yGCzEuu81tqV0m9op7Y3a/umNQ5aKJJdo7V9STvLJNeVhUxrfKhcf7QzSOmeAejnjFZx9p49P7xWE0trjTGXaH2XW9tbxVDH9B3ObJ4zpHamNdl+ZJ7UrLOlY2J5N8ug61jPElo9Wjx6+C4kYHW+5cZS2/M9hHbr6Y9Wzwta/5TGifMbakIIIYQQQgghpAA+UBNCCCGEEEIIIQUcG5fvUtcD6TJgcfGqTZMjseqeeqW/F09KplYpyFpR40bmwep6lLyWqXOsdAM5maWuLFq7atI1hDYcut32fX+eW5LmTljq1lbj+t+K0rQrnrkwVliF5ho9uJH18IWKSErclmNrtGYjmq4laTlqqZmbYVk5h5bpbhZhFdb0YHKeaDrUpLcKy8bcvFNltXCDXBiFVo+mj6m/IvVqYTC5cR/D3VnuC5LoeC/ci7XzgceGt7a2Vn63pvbMuadqe7VkHXtyaUoyiz31iLdBW6NLU/7lQgbGOGd45slFF1208vsXvvCF5L2ec7R1nZO61tiWtS/lmFjSzVquedz5Pe7z6wiV0uq1jp8HfkNNCCGEEEIIIYQUwAdqQgghhBBCCCGkAD5QE0IIIYQQQgghBRzpGOrpdLr0kbemrMihxa140uR4YkjC66m4se7goCwWJRKP0ypdQ03cQ2mMzRjpEbx1etJChXhSWNXErmt9WzqepekZcvqk5PV974otzsVbpu7Nxfxp68Ey/iyip9Qn/F3G6HrmQhjz5hnLZUoyQ9qssGzYxul06lo7hvhdS9qsEJkGxmPD2hptSvUUiSddV/rEUrT+kH0uU56UxCzmbFSzvVzf1ryrIURLbehJQTRGmkFZp5wn7vRbhv0kh/ddJMO7GFrNBW1t0OL3c+vRJt5p0EKGZ83zzM1Uvd55ImW+6lWvwk033Qfvfe898LVfewv+83++fHndlL50gdw3Q7vwpH7UYqYl2nuTJKV2oKXuG8u2PGdIbY6VrLuqDAyiyt4ppOnqmTeSVDowTx1H+oGaEEIIIYQQshluuuk++E//6TswmRzgj/7oYQCuRNed2rRahKyVrl/X64Ybsre3h52dHbwawMWLv1B4m3EZgBsL5ZeWtZRL/X3+xIgyW5dddzlr2bBvB2s5rP0j7aBW303qGut3rZ4TAE5n7tXKrssONJnnzePIt9CtZVrLefq2akwWbT7R9zjt+AatRuZArG+176c1O0jZt0WmhXWWk30bYunn0edJhNZ2oKHZnscOPH1bOk9CeYdxD7uQZR4lXVvI3L3Hb+GVt/yv2McMU5zF0/BSXIMXu2Wq32Yv/h1zXxhrbbeuHUddZgmHZW6m7OAOAFcDmM/n2N7e1ivvjyDz+bxftHn56bpu+ZHXYp+TkXLesin5qXpqZU4mk5WPR6b2SdUTk1naP/ITq7NE1+FzcnHNol9M1+l0uvKxtNmib/h5whOe0D/hCU/o/+wrv7J/whOe0P/8z//88uPVt9T2rGMytDvVP2G51LWYvbeyg1QfnMT5/SHb5ZFpmaexeeKRmbLpnEztXm1Oe/tWKzfGPPGMiXc8c/XsJuaB1rea7Xna2WIfqhkTrd2yf1qNpzZXc/PEonvtmGifUturmZultp5ai4bx1PpHmyee8Q/nyVj2UzOeWjnrHib3TU3f3L6Z2m9btzFVVtvzzy93ZQ/0PXBm8e+VJpmy72az2cqn1fkgLFu631rtu8V+29pmU2tra5nauWcdzxmW81fpHjafz7PPpnT5JoQQQgghhBRwCsBVAC4HcMPid0IuLPhATQghhBBCCCnkFPggTS5kmDaLEEIIIYQQQggp4IL/hrovfCdb7pX0XfByhS5IG5J73b+HUt09eF69P1FSjkhdx+gDT3904tX7nnRApVx33XXo+yvx5fhxvOENN+ANb/hRc9mwbyVF7Y6U08ZE659c321tbS1//uIXv5iUmUuzpOkeIq9p90o78JQtlamV7TJpRKzzJidf68uJkkZE6reJFFKlc17ry6GefvH/sp0p+Z5rOaxjAuj9Xjomljr7zH2AT1fPvNH6RF4L53XNXNAoHesaGwn7Uq5dmpzUGFjGMyZ/KCfTAa1jHw1l5uxnuDeW2lD22TrGM7TZXF+toy+1c4UmX571pA1pe0iIvNZqP5Fr0HKMMqkxJaH9TKdTNd1V6TksSWU6PE2/GtuP6r7QdYy9p3U93jXPA7+hJmRN9P2VAE7iD/ECACcBXLlhjQghhBBCCCE18IGakLVxBYCzOMAMwFmce4EHIYQQQggh5KjCB2pC1sb1AGaY4CzORVvcsFl1CCGEEEIIIVUcmxhqawyAFucr69FiwXI++Fq8gha/oMV+5OIZS2MttHpkHKtWTsZXhW2R7WoVHyRjXKz1LuPaE3Eq1hhKX4zrLoCr8N24HLvO1BJh347FEMM8oI29hozts8arDPL6hOyw3+90pzutXJOx2VF9FqRiur3zR4vTLJ2brWJKa2KEPDGvHqyxqrm49lJku8JYzOV6EInfb7XO5jDtA6FOhv4pjcH3osUzh7Tsy+r3Z0SQ54MQ2Xdj7Leeez3tr7GDmF0O/ePZx2vfV1Mic7g3Jllbs8eKpS+NY9XGzxNLn6onJlmbJ7l3Kmj2Feqbw7qned7t4Rmv0ndHeJ4PWty3TqLrQcT2cmPisYOQhz3sYQCAu3ziE3jYfe+LD33oQ8trcm3QzrRj7OvH5oGakKPBKVyDU9jdtBqEEEIIIYSQaujyTQghhBBCCCGEFHBsvqG2uuh6XDha6eORqV3PpagIZS5dMQyu0GOliwjbInUPyaVg0FyxQpcujytYLv2Hlh4hdV8NHpe8GleV0pQ/HpnSFXEMNxvNxVvTBwDOnDmTvLe0naY0GAsGl/PJ2bPYms1UfTTGsgOPzNg6VytT2o+27tW4z8bWiyHcQM5Hq4ycTM+80ZhMJlE3u5jMUlql8QrX91y7wrFe1rloZ6uUbZYxGPt8YKVViEUrm8idZUwp9yJ2a9lja8ckJ9O6dpjSsCXCMUr194xfTahiiCcMTqL1V4nLdY5WIVfWEIsYnr7V9pdqGzGEAnnCC7Q+0cI8a8JiNf2e9KQn4SMfeQR+7VNTPPjB+3j/+5+TrGeM5x6NY/NATQghhBBCCCHk+PGRjzwCp049G1Ocxf6pGc69i8j+PqIx6frDGPWeYW9vDzs7O7gWwMWFdVwG4MbMPfLvcUNHWcqWytTKnk7oE2PQ/cSiXMkgt2xnqi/Da5vUVdNvLJkhVvlj2l5Mh1qb3cQ8OewyJ4u/on5z3+MdXYeDgiV43e1MlQttZiyb3cTc1L6L2cTclHRIr5cW3dc5JuH67lmDpK6bXqPHLrvutX0MmetYD0poae9j2l2qrMX2OU8On0zLPJEctucMDW2Ntp5qvPr+3vav4tq9f4x9zDDFWTwNL8U1eLG5vFfeHQCuBjCfz7G9va3f3B9B5vN5j3Pjtfx0XZf8yHsB9Ccj/yc/k8lk5eMpG5NvKZf6nAT66XS68tFkDvfsLspZdW2hb6ycpvvQv7uLny19WTKeWjmp3zpkWmwtVtZi3yW6xsZoKNdKZqu5WdNOzdZL26mtP7Kera2tfmtrqz/Vdf3W1lZxO71rXgublXKsNlsjU1s7PGuXx/bkfCxt51j2Hq6X2piMtYdZ+yS8d9cgM7YGD7bukdnK9sYou479VspJzaHWMrXxkeM5xh6mla2R6bG7sI2t+tayBg4yxzrLeGx23ecnTb5njq1rbrZaozU7KNVX6iPtSdPVuz4PZT1z88orf7kH+n6KMz3Q98CVyfGL1Vs6lvP5PPtsemxcvntjyhFPmqWa17yXyuyUWIJcjHDYbk9sce/4hswUWxiJkbL0c4943IWmXyfiRjpj7I4nFYc2Jp57pa6eeJOwrGe8PJTGm+T6pzSdk6ffPeW0euQ1zZ5KdAO+FMN9AD2e20vU1iLXWsmowRODK+2y1J48Y1vzLgtNZlR+IhZaq+fg4GC5XmoxbzUxp9raldNX6gqcW98l1nSKfWTda5UmLkRrZ02MZFh2rBSSEs/ZoRXRdE4R5FjK9DatdPfE75vivw10XZdMx1lKSaowC2H/SDxnGc8e6yGajq8yRlh7X46HVudCT19Z68nVqe1hNel5S8dd25vl9VOnngPgFJ6G89PPturLUo7NAzUhhBBCCCGEkOPK4Uw/y7RZhBBCCCGEEEJIAcfmG+qoa0iEnCt06AYgXQI8riFDahzgS26dKZmh+0WN63FYVktF5XG3lGipsKyppiQ5l3irG7d0C9TctDypOGQ7PWmgUrr3fa+m/5G0cqHyuK5ZZebus9pXLn1a7F6LjJoUFaEromxnaAcePO3UqHHDb0Vpvaa0cAlX6NKypbp6wlc8aC56JS7VsbJjucCV9oHHXV4i9fP0kUbK1TfmZq7Jt7pcJtvR2E24FaX2pN0r12S5llrSbAL2NKQWrbW6PGksw3CMmjXI6oLucfVttf+XuixLcvv4GC7NllBAi5zSUERAD40Iz8Oz6XSUtKOt5vFYa1ervXoM93QNfkNNCCGEEEIIIYQUwAdqQgghhBBCCCGkAD5QE0IIIYQQQgghBRybGOqQ0tQ38t6aFD+e+EprupuS+IB+8bPWrtLX/7dKVZKLa6/tgxgyjlVibafndf9SZqs4JA+euLYxdNL6R8a1W+4d8KRH8cSRaekkYvIt93ri90sZK42QJ3VRq/iqscpZ1znzexIazhdTTHXjlDXriJn0pH7U4ilj10uJvV8k9n6DVvGL2tlAm1/y+iZSxHhiQzVyZxDrmEi0ddjTB7/5m7+JP//z+2L3tz6JF/7D++AlL7kiee9YcZrWc0funRPa+UmLMa9Jm2UlZy+lMj3pcD36hHhSWHlsZFgfepy/VrRK3eeZQ7n3FqXua4n2DBe+56bVOzlK95Zj+UBNCCGEEEKIlz//8/viJS+5HFOcxf5LZgCuRJjvlhBCJHT5JoQQQgghBMB733tPTCYH2McMk8kBgMs3rRIh5JDDB2pCCCGEEEIAfO3X/g0ODiaY4iwODiYAbti0SoSQQ86Rd/mOxYx4YmU8sY9arJwW81YTdxTGD5XmEKyJJay5VyPME7hs/xrzcNbEsWp2YIlbicmsyQ3uQYtFKY3P8cTOWubJECvnyf+rxYJ5cvxqOas11jFegH3+5fL9tsrha41RzOmt5QIuWaM75xrisVnJco2uzE8dttMaF127Vnpy+tbKsOxhrfLkemSU1rOONVuLNc7FlJbmj5akYgs9c3qlvkg/la5HnrOUR99zMdNX4mm4HLu4AZPJH2L4/qn5+ykS+lnHz7NWaXu1Z8/IydR0D9cDD9ZzRK6sxrr2Ta0eTw577V5r7vJcOU2HGl097x7R5HjeV2Wts5Qj/0BNCCGEEEJIO07hGpzCLgA6cxJCcnT9ul4v3JC9vT3s7OzgWgAXL/4v/FuIpUGXAbhRlPOW9VIic7j3BIDTjnJSZgm17dSIjddh1dVT1jK2peVSZS20LmeZb16Zmq1rcrwyNdvT/v58WMbEUjZlT4dRV8A3Jtb1cl3tbCWzdA8rYZ0yPf2z6X1BrkEWWxvY1Bzb5Ny0lguJ2YHlez/LmKRouQYd5XOXVnZd58tNrNHWsodlTlPm4Sl3B4CrAcznc2xvb+s390eQ+Xze45ytLz9d1y0/0+l05TOZTJaf4f6TonysHnltqG83U07qMMjeBVZ08Ogekxm2K1Zvqp1S11Q9JyP3av2T69vcp6TcoMugayuZYX+k+is2JqW6rqtvLTJy5bqu62ez2fKj2U/O9lqOZYnM2n5NlZXzOGZbqfVA011bgzZhBx57L5VpWedajWfteumRNdba5ZFp7VdtLK1rmcUOUuVi9Zaul+HaNZvNisdEa2cr29N0z5Xz9E/pnLactSzt1MYzXPPkWio/cm6W7tWarrLu2PpgWdtr7MDTP9rYDra061x/cuvBGGcZbd/0yNTW81Y223IdGWPvq1m7Wux9uTHxtLO0nPczn8+zz6b0YyGEEEIIIYQQQgrgAzUhhBBCCCGEEFIAH6gJIYQQQgghhJACjvRbvrtICirg/Ne+94Wvdo/VbSkHrL5uX6aPmM1Wuz3UV76mX77GP1VOyilNgQQEben7taSwqqEXqRSsfRCmboilaLKkB7H0TKekmkhdy5FL16L1gSZHq1f2zxipCmT/tGIsG9bSf2gpvgZ9+sXP4Xog+zW1rsRa5Jn/2jpnHaMccjzDtUzrH4lm31KfoS2xFE2pe8VN2bRZyXoy6WNkWY+959K5pO6V90mZpXPDYyPhPDGNgbFeT9kQbe3yrNGt1pWtrS0AwOTsWWzNZjhz5szymrYv5Qj1y+0Z1rbI/vHM48EuLenlYjbcL37WxiTVP5bWafPGs7aG+snxC+vJ9Z31fCD7R2IqW7l2laaQ8+w9Mu2o1j9yvQxTs8pr4XpQsxdqqR+tfRnWM5xNW60zpc8H8nml9OznQesv2T+t0ti1SCHJb6gJIYQQQgghhJAC+EBNCCGEEEIIIYQUwAdqQgghhBBCCCGkgCMdQx3GgIVxEZr/exjvFovB0uIywliVXFxDzB9/iP3wxERoMZNafFUYrzSdTtWYYBkTURqbtglkPEUpY8XHRWNVI3GaOcKyufiOVjElIaW6ets5Bp64KC1WNTXfLHPTGjubi0XT1i9t3OV6ELbLGgtWyxh2kJq3pWt0Cx00rHHbEhkb2XVdspwWm1kaf9bq/Qa5eLxo/GminaXvoNDYxNo1xEwfLH4ujdvW1g5P3G+1PSfq0c4ymg3nzmyleN5LUIrljJaSr73nInp2NczpVD2dM4baQ3LMIvV5YrEt8daxe63vUPBSqmuqnlisuGe+afp53pczxnlSUtM/pe9mGaOd/IaaEEIIIYQQQggpgA/UhBBCCCGEEEJIAUfa5Tuk1HXN4+IZFPQrmNBBytFSWOXqCZGpFLRUM0mZGUpTJUhybnaaS8fSlXUxlmHKEQ3pNuJB658hBcpAqE9N2qxSN7yxXBY1NyRLyrGW8ldwzhPpAmtJd2WhJKwjVk5bn0pDR/YXbt+xOoHxXLwsaeyA1TUvth6MGY7RRWTWrHMm2zO4siZd2zOumqm0QiXrnobmPh/KzKVcSaYodIY4pHTzlKvBI1MLWypxhbQg91xPOierfh6XYa3d2r5pTo0Xkd3KxduTXtUj3xuSYglzkYRzUzu7pHSzuJl7Uk+tI6yjhlb6eNyUQzmm5xVDuEqrPUzKDPVrmV6rNBWsRAuVKnUdX9GzqBQhhBBCCCGEEHKB0/WH4c8+Tvb29rCzs4NrAVxcWMdlAG4EIP9+aOmMoaxGWO9Qp7ect2yMWDtlG0tljqWrJkfqPln8heyb+x7v6DocOM25VNdU2Yn8FiWiT2uZrcrFxnOTNluCt+yg+wkAp2Gb/7UyPeU2sR5o5UoYc71sJXMgZgfWPWLdtneY1hGLPW1qPTgt/m8d9u6RKe3AWi6UV2sHm14PLHNsk/bu6Z8O8bGU5ObJusfkHYazy8Bh3zcPi8zW6+WhnycF3+DXng9azZNUPXcAuBrAfD7H9va2Xnl/BJnP5/2izctP13XLj7wW+5xc/DudTlc+qTrDz0lD/ZPJZPmRMjXdw3KTycQlU2tnTJ+Yrh6ZslyunalPKC82fqnxAdBvbW31W1tb/amu67e2tor7p6ZvY/oMH62c12at+sbq9drsMJ4xXeWnlR2UttE7N2Nt3l38PJa+pXaQWp9qZWpzqmUbS2wvtx5Y5k2JvafsIGXftX0kZWpzzCOvVf94yo3RP7KcpU9iZa3jF8pI2d4YMqUdWMvV9Kts5xjrQWq8YmVTZ5BYOc88Wcf5KbYfDmMp12/PPPHItNqsNiaWs0vKZmv61qrvWLbn0bX0OUN+LPMtVtbyvFK7dmnzS9YrZc5ms+WnpR1o50vPeln6nAGgn8/n2WfTYxNDXYoW69Qrf2GR6T/kvaVxWrKe8PdO/AVR/q7JLL2mkUvpo/Vf6i9ZsTJaXPsQp3HQ9+fFbNTEzpWm1NHijrTURZp8rw5av2vIvp1Op0tdtXvXEZMoKW2jZKyYUg9aW6Lpks4Vcr3/QcoYI0WMB23tktck2poYXsvFBIZlwxhzmapE2oU2N3Op+2KpjGK2l+sD7d5WcyMqIxJzC+j2FK576yKUWRJbHIulT8kYCPvAk7qo1RrkWQ9kO636emzLY5dj7W/aWuGp15pyaKgnto5IGbm0WR6ZYf2eM20YC219/0xYZ8pmNZsJ15Ic1rGuOS9Zdc2dvz1nIk9qQ2u53DnaSq6sdnYPz+At09JZY/Rza07Xdcm1vcWZiDHUhBBCCCGEEEJIAXygJoQQQgghhBBCCjg2Lt8l7sWA7qKrkUoNospfuBp4XLXDsil3ncPC0lVlkaYr1LfGlU1z1dLcXDQ3ylxfVqcAiyBTF2n3juV+HMrMuceErmsSj0tRi3QELSl1YSyV0VJOWI/sy9CGpbuVXOe0MTG5wCWuW9HKyTldOjc1F2+PDh5yuln7Ntfvi5ui+8lYNh2i2Z6WNqsGT3+Fa22J67HF/dqzlrVacyxtttw7/J5yTY7d66XU7dYj0+Liubhw3ppYmn4nF55hPYvmXNBLw840tHADT5jJEkNohCQ8J8rQydJUSzW2puFxoy4ND5EchjA0jbCdmnv66GdYQ7pJycHBwbJfx9D3cD2REUIIIYQQQgghRwQ+UBNCCCGEEEIIIQXwgZoQQgghhBBCCCng2MRQl8YAaX70WmxMaZqHPhILXUppDF5p/Cvge22/9VX3OUwxSYZYnljKiiEt1FhjEtqXlhKtBk8siCcmaDKZJNOqaPFdckys6cGWqVwMacVyeodoMW9LmYuYmlZxP+uIY9WQ8cMy1ql0bnrixJYyInPTtO4aYqSS1/s+mzarNE7TkxLJU9bDMgY2sp+M8Y6AXDopS4rJydmzyEW8tdoXSuscdO329zGbTl0xnVp6ME9qF21tHaN/PPfKdaSVjLHWS+2dE5Zz4dDOWIo9Sz3atZxtWVN+eVK2enQtiqk2EL7fYKz3CWiMtR543m8wBp60rK2Q8d6l7yka6wyrMUaMN7+hJoQQQgghhBBCCuADNSGEEEIIIYQQUgAfqAkhhBBCCCGEkAKOZQy1J/ZZiw2VeOKgNFrFEpTGcUu0XICeOIxN5M/zxgSn8MQIh/FVOWJjG4s/q4kFaR0nORDm7JNYbTYXlxXNcY1xY45i8bol8VweO1gHlrXCMjc9sWnh2FvfrxDqY8ETsxzeK2OmPXj6IIz5zsUWW2PMcrGz0+nU9P6HmrUhlqvcksNTXhvG4QDn56LOxZyfE+rPdVtKGPefs9FUH/TQ99Tc2cH6HpdcPHOrd4/E6hzWy9J30OSwzr/c/lK6x2rrZWneaXmv9v4HmV/etAY2nic17ygw5dA2zDEN694j8YzfMG975GPeW727ojS3c7hGryN+OoZnrobtrLGDMd4ZUgq/oSaEEEIIIYQQQgro+k0/0hewt7eHnZ0dXAvg4sX/Wd9HODT2MgA3Rq5r9eTK5hjKSRnhAKSu1crUSP3FbkyZLctZy8bG9gSA04h8cxL8nLp2wiAzVS4m08JhHJNN2KxW9nRCn9YyS+2gRmZt2dbltHkylsyU/FCHw7oGaeUsfTnQ4UvriEbNmMT0Oax7WKuynjVaa+dp7ZtJpdxR20+Oqx1sqlxY1rMetJLZqtw69gVv/7SQqaGtlx7kvA45anagsanzk7fcHQCuBjCfz7G9va3f3B9B5vN5j4XXkeUzmUzO++wu/t9Tz/A5WVAmLCd16bpu+ZFlptNpP51O+11Du6y6hvK6rkvWU9tOKUdrp1ZujDEZ6j65+HksO2jZr9bxjH1K2mktlxovi64pW59Op8Xj6bF3qatlTrW2g9lstvx47KDVPPH0Tys70MrWzBOPHcTGZ9gXvP06tr1rc9pjB7JsONaDPsNH01WbJ9p+0nJt1/YwzQ5kO8P51+p84GlnzboX9k/N2qWVC9tRq6s2nlabXYdMWW7s80iunZYzY60d5Mp51miL/Ng80dag2jFJ6WvV1Tp+ljGx6N76/D2G3R6256kx5c3n8+yzKV2+CSGEEEIIIYSQAvhATQghhBBCCCGEFMAHakIIIYQQQgghpIBjkzYrRL5qvo+kTugxbmqn3d3d5c9Pf/rTB+HRtAby95DwVfgSzyv1Q7qKdBZaPUGF57UzeW+0uF2frjL9h0We1H34PZYuSd4bjsmQSqXb38dsOlXTMGh9a74X56ewMqWzGBGrre/v77vsW6tXXrP2F6Cn/whtTxKmHJI6SJvV2iXrCdNhlM5bwJeiKcSzdsj0H9bxK53TKzIjaUO0empS/ml2ULSWRcql6on9v7WePpLmK0UuJYt1XfGstbl7rWu4XEcsKWVK7CC0d8+4a+uepoNnfmnrCGCf81JXLT1YK5b77RrTp0larYlWGbKOVmkGa8qFNpQbZ6sOsp3SLkP7Wl4z2IEnnVt4LTdPrHjmpkTufz/8w6/FBz5wbzz0oZ/Czs6bVu79d//u3+Xrifxec/YL+yjU1dtODdP4Gc5PsT4oGRMrx/KBmhBCCCGEEEKOIn1/JX7xF5+MyeQAb3zj1+OZz7wFD37w+zatFklAl29CCCGEEEIIOTRcgcnkAAcHE0wmB7j55q/etEJE4Vh+Q13kXrHA5NpjcOm56qqrov/vdQfSZHrcUUrdPTSXrlzfWd33alw8Pa7bpaRchCzSQveYZb/3PQ4ODopcPGOYXF4i7jFaaET4u8f1Modnvq3DtS9ne6VuQda5KeXd6173wuc//0R88Yvfgjvd6c9w5ZWr13/jN37DVG+un0vb5Rmv0vCaGhdPLcykVWhLzVwNyblRZ3Va9E/2vgBtjdbuleU0l7zSUKSYHKtMjbFCW1LuoTlraDU3ZZiCVq+0L8+eawnTqUXTvSYco1SHVntP6fnSEzK3rnNPONbSpVkLq6jRTztvhjI9cyi3loWUzpOa0NJVGW/EwcGPAjiLg4MZTp/+9zh9+pSpHi18zYM2tstrizOtB9m3IdbxKzmb9oZypRzLB2pCCDmKfP7zT8Tf/d0rAZzF7bc/Bx//+M/jfvd756bVIoQQQshaOQXgKgCXA7hh8Ts5rPCBmhBCDglf/OK3ADiLc0vzWXzmMw/jAzUhhBByQXIKfJA+GjCGmhBCDgl3utOfYXiYBma49NL3b1gjQgghhBCicSy/ofa8+r5VfJ7pXkPMmyc+r1R3D1osg7w29Hu3SP1REkfqTWHlSWehxZFr8TmpVA7d/v55se25NBBAfSxYLhZGpspK6SZ18KRAKY3p8qRZGiuOLWUHMq2YvC5ppV9Yz6/8ypU4ffrP8J733B2PeMT/g89+9j0A7lRVJ6CvQVpMWS4Oax2p1zx2Gcau5cYn3Cdq9gjPuzVS5bxpYIAvxZhra1nN+w8sacZiMlutbbIezRa1fdNjs550N6XxwzWx/dF1d2EHpe+nKEpL1zj1TOn7VyQ1aY+s8y/XZuv7DTT5rd7TUIPFfoazjLYepM4rlrSjmh14bC+0W4lpPTDEtZemfvSkn/XgiUvWsKal0sYuRqv3H3nmZvheoFbvWAk5lg/UhBByVDlx4tM4ceLTAIDXvW7DyhBCCCGEEJWu38SfvirZ29vDzs4OrgVwceS6/LtIrIGXAbixUH5p2aMo87T4P81Yhn4/sSjnNayx+ye0i0G3VLnYvctri79snej7QzEmklJ7j/3Fbp02W2s/VpmaHVjWjhKZ1nLf/M3fvPL7LbfcsvL7zTff3FymZNP9I+0ABX9Jbr0eWFjXmAyMPU9alrOWbbVGhzLXuYcNMrV2puZQ7ZhsYm4eNttbR9+OuSfUlD2sMlPfU55wlq0Zy9Bu12nvh3VMWpU9DOvB2HPzDgBXA5jP59je3tZv7o8g8/m8X/Rd9DOdTlc+sXtOKuVzn5NA33Wd+gnvH/7PW66FvrXtnEwmKx9Lv+8ufh5D11R/xcrKe2PtOJm4V7Of2WzWz2azflcZr3WOiWWMLDKHdg0frZzFhr3tHPTfXfxsnRu5dlrG9qTQwWLvteMZK/f7v//7K58f+qEfWvmUytTWoNQ4xObJOvpH2kHMLi3tzMnR7KC0b2vGxNIn4WfoH83ePWNimW+W9aDGDjTb0+7V1iCPzeb6toW9p/Qp2f9C+xlrbsb20DH7J2VP3jldO6/Dclq/amPSag8bs9wYMlPnLrl+5foyNsct66X8aDKt5eTYe878VluP2VDpmKzD9rQzv/VZZ8y52bJ/5vN59tn0SLt8d0HcUOg7r8XNdCK2Qcux1infjPSOL/aHelIxb5ayiMR3aljjHs5VvdqWMBbao2urfJGt+l3eG/4exkHPptPz4jI1GxrutWvSllzfWmNKZD9rsakSzzhYydlPp8TrePLgRue4IR5Vk+lBxiGG9X7v936vKiOcmx60OeRpV028riYzpl+/+Nm0novfO0OMlLxeomvsdyuedS02Jql50kIfiZwnGjKOdamjYUxK9ptW94X3luxh4bz27GFa31ptLfb/nrmpvU8gNTdza7TWzhxW3WV/tcqLLdF08IzJcSVnt7FrsTtK7V2uOZIwR7xHV209qBlfq33XyJBlPbHGIZ73ErQ6L5WMUQztLNiqf1bqKCpFCCGEEEIIIYRc4PCBmhBCCCGEEEIIKeBIu3z3fR91BZBpVqLuUIvUTimXSqDOfSjmPmBxI9va2lr5/cyZM+fVE5MBrLbT40YmCd1jPHjcLTU8Ll5LmZE0HtJVJax32caES2kr1zWNUnfZHFZ3lRoX3fD3lF2OmVql1AUIWF0fQjf3nNtkq3bUuJVqrmuarqGr+HQ6XbH5Vm5lSVfgSPoPzd2qRVhHH7kmCcdes1lN15XrlXO41d6jIfcFa197wpZqdG+1JsrxDGnlsi8J57UWSpajlT4eF/51pADT1gqP6/9Y+2YpnrRsWriEFpJiCldJzGmPzFJK3ZaL3Ikj7ZTlWrVZkznWGXddqelCtDOt1rfhecS7hmgyx7LLLkhpp605pWsMv6EmhBBCCCGEEEIK4AM1IYQQQgghhBBSAB+oCSGEEEIIIYSQAo50DDVgS30S8+1P+fxrcQBaWgwtjiYXtxbWFcZMS5kST6ys1k+52EdZVwoZG+pOS2OI60umUVhc015970lvMVYqg9J6StMltYrH0eIOU7YfswNXPIqSJq4mBYMnPZg1HVdRiiZDCqLSWMxUuZJYJyu5OaPZQWo8W8ZIan3tiWs/d/1KAFcAuB7AqSb6tRoX6xqY2xfCe1ulRCyZ/8Pa5Yl9DvXNlRsjJjf3vpPUvbl1o/S9F2PFGj/rWc/CzTd/Iz796YfhXvd6P37kR75qee3pT396slyrOFZP/PJYeGRqMbie1HSl6dPGSl1USm7NS61lOV3GOKN51h9PSsRUWct7QEJq1svwHRk5WqX88rwrqXQ8Pe8TaMGRf6AmhBBC1seVAHYBnAXwQgBXodVDNSFHiZtv/kZcd92PoOv28d73PhGPeczb8ZjH/M2m1SKEkLVDl29CCCHEzBU49zA9W/x7+Ua1IWRTfPrTD0PX7aPvp+i6fbz73V+5aZUIIWQjHPlvqGOuAK1c57S0NFKulOlxVbG4TcTu0NKBeNzaSt02cm4Z1hQDNe4xnnQupS5wmu4e16wa17XSVGYaHrcaTb+cG5m1r3Pu6aXuOp70MaXpuEpdNa0p7Cy0cnccy1V03SluitzwF4T2/vrXv37l2uMf//M498308FB9Q7QcoI+J5qKXc/XX0n9olKbNytEq5Vd0f1z8fyu3Pw0tvVwrmR5XX8/aJctaQ1JqbOC97305gCcCOIu+n2F394XY3c17a3j2TU3Xdbl4h/PRYxOes8PyLLNI6WpKIYX8umYNW5JY0l2l5kmrcC3t3tI1R6bV1ULAtPVSS8u6LG84y2jn5pJUXJb1MmUjPQ5HGMVYoS3LPsrc96AHPWj588HBAT7ykY+YdDnyD9SEEELI+jiFc27el+PcwzTdvcmFSdedQt8/HZwLhJDjxO23/33cccdj8WVf9mYAfKAmhBBCRuAU+PBAyLmH6mEurNkJGRWAnwAA2ilJREFUhRBCmnP77X8fn/70LwE4i/n8mQBeaSrX9ev2w2vA3t4ednZ2cC2AiwvruAzAjc4yg2PBCUPZ0KFi6OASmQOxstJpKjaQQ7mYPiUyD1u5cExOw+8S3XpMSstZxrJEZqv+seoXK2ulVtcSmbXlLhSZR0nXFjJDe3/s4x63cs9b3/rWZNnT4v80G9bs3bO2p+rV5Lcek03IHKPsOtag1Ni2tNmwXkvZUpklHEWZ3vOTRV7K6X3Ms0wr28vNE82hfwx795xpTxe8QdpyZotxFM8yuT1sHc82my7367OX4Q/O/jAOMEOHz6HHV2A+n2N7e1sv2B9B5vN5j0WoQNd1fdd1y9+tn5OJ/x/q67qu39raWvnkylplTiaTlU9Kftgui0xruZSMmL7T6XTl49E1Vc47Jp6ylnZ5x6S1vjFdrfJPrlHXyWTS7y7+tdqd12ZLdZV9MHx2cb7NSv1in5OLdqxD35b2nhqH1LytXUc8tjfIHsZEm5utxiS0g5p+LZ2b1rXVM5apeix7WGouWPo21gdjrwez2Wz58eiaGqOWa7Snna3soFW51ute67VLG09ZLrzmOct4dKy195j9rMsOtPVqHfOkZTtbnIU9ZVv1z7CG7XZdP5vNqmzPut9q5VqeE1ue9VJlLbrXnvk1mV/zNS/qgb4HzvTAuefN+XyefTalyzchhBBCCCGEkAuau93tzfiar3kx/uf/fDTufOe3wvhOMsZQE0IIIYQQQgghd7vbm3G3u73Z9QZ55qEmhBBCCCGEEEIKONLfUHdB7sVU3mcAai5gLefamTNnVq6FeUNrkPppuqfui92rtbMrzC0r/zoT5t6T9cjfw7KenNkSTXctl6tWz/CzpZwkzMGoyZBo/eWRn7s37OvlvQV5Zw8ODtCjXZ7pHLk81BphHsVcTsxUvZ5+1erx3ls6NyVh2Va5gOU6UjomBwcHRfnuvf0RypRz0bQ2RNZLT5tbzYWc7p2Sh9pqBzldY+tTyXoQ9m2OsG7P+ugZo1a5eEuvSVrlvtZopavEM8dCZC5gSZgbWM7N0n3Tg1y7tDVa64PUeSWUUYvnDOSRKfMsR8sazhVF67DhXq3cz/3cz+E973kQ/uqv7o8HPehm/PqvP3N5TZv/nv7RznrDHO77Hvv7+65zoWZ7GuEa3WfyUGvkxqB0TFLXY89Tm9hzQ5k33XRTUf1H+oGaEEIIIYQQQgDgPe95EH79178HXXeAt7zlmwFcCaY5JGNDl29CCCGEEELIkeev/ur+6LoD9P0EXXcA4PJNq0QuAI70N9Qlbg1LN4OFq4p0r9LcFEJXjJaErgY17iihi07YLtlP0t1K9oHWp6XuaBb32JSrb6hPqn+8rogml8rEtVCmdItyvcDA4f4Vur1JfaQOKZczj6taDo/uP/MzP4P3ve/B+MhHHoDPf/6PcM97vn157Y/+6I/Ok98jr0tzd+uIq2+oU64eD5oLY/LeiD6yneG9rdxGpf14bGYs10yr+1wr9/kaPLbouW85VyJ6juFWWoM3zGRAzhOt3q2trZVrYbiWLKv1ybA3dvv7mE2nK67HOUJ9tXGX+izdQxc/p/bxw4AnLEdbKzxnDg0pwzPWHlq5UY8xH5e2trA7zWZq9nzt/GQtt1I2Ils72yz7zuD6/5a3/DSAkwDO4lwyoxvOr6cA69pa088Sa1nPXu0JU5BYQ9Ry502rDItOLfDol+JIP1ATQg4/73vfg/Fbv/W/LP5ifBke/eifXHmoJoQQQghpQdedQt8/Hee+mb4BdPcm64AP1ISQUfnIRx4QuF/t43Of+3o+UBNCCCFkFLruFIYH6TV8wUkIY6gJIePy1V/9sWUsU99Pcckl/2PTKhFCCCGEENKEY/MNtRZ3FEuBYom5beXH70mLUfPa/liaqlisk4wLaxE7UEMsnVUK2T+eeNSYjQx2oMXgSVqlJ2qVGqBUB1OsTKJfPbr/1m99L4Ar0feXA7gBf/7nX3K/SsXjeOJ4Vuh717yWMjW5nrhIqYP2foNWKVlK146alG2t4nWj42lIC5Wsp/IriZL3CXQHB+e9n8ITgxsi+yNqew3mZlbGAhlbLGVYZVpTqcg6c+Mh12vtnROazGG8euTHrjQOUV6ridu26pO81/keB3l+0t4hklorukwKPck60mQB5WuZNm88e0bpuzRkiqZWa7TnXOF510fpOxXWYQepmHxvKk+Prsn+McxNWVbTtdVebe17c7rSChlSzljpE60cmwdqQshh5kvuV4QQQgghhBwXun4dr09rzN7eHnZ2dnAtgIsX/xf+XcnSoMsA3Fgo31t20O0EgNMoe0v4UZBZWm5dusZsZCg3kd8wGqbFuvpnkzKPkq5jy5TfrUkbspYtLectG6N1Ocu6e9zsQLKyfhV4NZXaQev+Sdka8KVvak70/bk2Sq+BQpmS0nlSI7NluZKysm+9R7JN9o9mM5JwnhzGMWm5Rpf0z8BxW6MPyx5WUrb2bLrOc8VAStd124HV9luuQZ75ZdXvDgBXA5jP59je3tYr748g8/m8X7Q/+plMJiuf2LXdxc9aPanPSaDvum7lYy3nlTXUX1LWKjPVljFlTqfT5SdsY9d1542fpZ9rdZV9MIZM2U7NZlO6tGznWDZbWnawh93Fzzk7Tdmsdl+q3Sk7sLZTltPWIM+YaO2czWYrH82etDEJ52Ks30v7R7P3VvbTyg6krrn+SJW16ue1gxbzq6adct/U1qsa2/PsQ5Z5Y+kjTdfcHE6Ni2ee5NY965ho8zi1PlnOQaVng5Q+Lddoz5ho7Wq9HljWPM88aTUmrWzWYz+ptcI7N7X9xKp7zg5SNjzMTet6ULv31dh77VmmZp5o4y4/Yd/mZG5tbS0/UlfvGl3aP/P5PPtsypeSEUIIIYQQQgghBfCBmhBCCCGEEEIIKYAP1IQQQgghhBBCSAEX3Fu+PWmzNPpD8C63rlFaL62clk6qRn4qJUNvSHOyDqw6yFfvy9/DFChDf3UiVRJwvi2WpuKQ1+U1rV2t7EliTWuwlN916LruvJQsoT6tUo4ldXCWlffJejxlrde09Dqe1GGe9CjS9sKyWt/1mfRgpXj6TkvfIudmK/syzbdIepSx5qLEOvZy39T2heRciLRBW59k6sdc2RS5VGal54BWYxSmcPTMRTkmnjVHoqUd9ewZMf1i5NZL61rhGQPPvdralWMo2/e9ule3SNMTQ2tnbo224jlH17QzLBumn51MJmqKNg9aWW1uWlPGxexHk+lJs6tROhdytp6am1KeOcVY7P9EXVoa21L7GmNP5TfUhBBCCCGEEEJIAXygJoQQQgghhBBCCuADNSGEEEIIIYQQUsCxjKGWPvVaPI4WB5GLVdWwxo1KtPiFnD5aO8OyudiBZTzhwYEau9AqBkGLJVy57pRpiUNOxeeVxs5a4lpr447GilnS2hzro1S50liaoe96xPsxjIUcK/5M1huuD5549NI5n4stjMWYWmTm5pgVLZ7LU6e27kpdNTnJ9dLZvmXcI/LvcZAyv/3bvx0A8BXvfje6v/s7kxzt59jvm36/gYzr86zRpXHurWKEtTVZItupob1PwLOWlq5lcg/zxCwv/39xzbR2rFaIbvGui5CwnlbvkdDu1d6LUCND4rGhkFb7lGUfsNhBsl5D33jOYeFeLftOm2PW/aXmnRyaXSb7ObJvemKbS94vZHmngvbuA62dNe8aWMc7jrR5XSN/Op0m97AWc5XfUBNCCCGEEEIIIQXwgZoQQgghhBBCCCngWLp8S8Kv9nOvpC9N1yCJuj4ZXBhTLnCdwc3B6maWc18K3R9LUzBIrOkaYqkmWqUDG8Od0KPb4AbV7e9jNp0Wu5FtwtW3xh2mlWtW2F/rCsewunVpLvE5OZoLo3avJ+TDQ2m4Sg6ru1zOvStsZy79nHbNmv5D8l3f9V0rv9/nPvfBzTd/I/7LF/8R+n4XwKmkfqWU7kWau54nRaFcL2tCijRaueyW7kXS3dKTFsrqPptMEeVco3N7WPi7Fq6Sk6ft+WO5F6fKyf5Zh/tpS0rXaEt4kSWUbF1oZxuP27R2ZiuldI3JheFY68nhWQ9ahWCF5Pq2VThrq5A5D/v7+0lX+hbnpwvigZoQQggZg5tv/kZcd92PYIqzAH4IwFUIH6oJIYQQcrzp+qP2Jz4Ae3t72NnZwbUALnaWHf4GcQLAacSTiue4DMCNayon9Q2x6D7ILPnryzrbGZaTf/fztFMjrHeos1TXkrLDGJzoe5wu/Lb4MtTZQYm8dfWPp1zKRjZlB3JMJLExisnMfZ9Zq+9RmCeecjV2UCrz7ne/+8rv/9f/+2/xO7c9C/uYYYKz+G68FNfgxU1ltiw3hsyYzYwtc8yyY8pcl81yTDYn8yjpum6Z4Zn2OO1FLcsdZpkX2pjcAeBqAPP5HNvb2/rN/RFkPp/3WLyg0vuZTqf9dDrtdxc/y+td1yU/wz0nM/eF94Z1pspp+k4mk34ymfS7wc/Dx9Lek4t/Z7PZ8mPtq5i+Wl9JmZZ7Y7rKdlr6yiIz1ncnHfpZZGqfof93u841DlKmxw6k7ZXIK9Ez1bel5WTZVB/kbFaWbdVOqY9ljGIyrfXk7L3GDsbon5blUnPaq6917ZKfJz7xiSufxz/+F3qg76c40wN9D1wZlZFb90r7x7oP1cjM2Y9lPRpzTDwyPWNimVPyk9N3OIMMn1ZrtGW/G9sOWvSPR+ZY9j5WuU3rWjMmreZmeKa13nsY9yLLulsi7zCc2cYYk5Z9NEa53Nycz+fZZ9MLzuXbE4fRV8RzdY74PO3V98P9Fn27WEzHIg7DE68bpmGo6QOtXRpaO2tiZ1ulMvIQ1qOlhYqOXUCog6cd0vZK2yX1C8chN7aanFjMcCqVWUhJipgxkTLl79Z+l+3K9YMmM3Wtxg5qKF0PJNp6Gq5dnnq0d2tI2/+TP/kTIfMN6Lo34rv778BJ3IDQ3Vvr264wdvaczElRmpxSZJ9r67DsL0+7wntr+scqQ+KRWaqPtlbIuamVzenaqp2es0yqHGBLyzaQSkEWsz1N5vB7t7+PH/mRH8FHPvJIfOITD8Z97/shvPe9/27l3o985CPJekNM77koGBNJ6Rpt7UuPfFlWpurS2pmyg/Xv0ufwrE/aPLGca1JnmU2cRTU8+6b2fiht3L37W7ZsZK2s6Z8WfXvBPVATQgghLem6U7imP4mTm1aEEBLlIx95JF7zmmej6/bxrnddjnve8zTufOfrNq0WIeSYwLRZhBBCCCHk2PKJTzwYXbePvp+i6/bx+c8/ZtMqEUKOEXygJoQQQgghx5b73vdDy4fpvp/iy77s7ZtWiRByjDiWLt81cbaXXXbZ8udHPepR+Ou//np88pMPwX3u80G87nX/1FyPxx9fi9ezxjZp93pjA0pjXGQ8hTeHbyoeJ3bvwPLexjkqrbEgnthnz33JOK3KOI9WcX+eGNiwj7S+9LwvICnD0L5N5Oq02rTUrZWucm5qcVk5mw7R8g9rNmONE/US2pBnLZXv1vDk2tTWS2s7S+JRU/NkjL6V9qPl9JZ44vM88brW2ELPGr2Mua2M2x7rnROl8cyajFzZ0j7wvAtFQ7M9LV44pAfwmtc8B8Ap9P3lAG7A3/xNWWq73HsulmtQZYyn1Q6WNrtYtzT78ujjWS9brTml59+a+FxrLufcu0c0m9bWy9w7FazUvHNC28Nms9XHRO39BmG7PP0ssb57IPfOiZYx1haO5QN1K/76r78er3vdc9F1+/jLv3w8gD8C84sSQgghhBw1ToFnOELIGNDlW+GTn3zISswNcPmmVSKEEEIIIYQQckg4lt9Qay7f0kVBugy9/e1hXM0vAHg8gLM4l2HsBrMOHteQlH45TK6aEfcP2eaUTIuLXgs0d0tgVT9vuqkUHjfzsVyWNDwulR5aueSUunhZ3ABL0gGFrpqpazE8qd8kpaEakjFc0HNpJzSZMZfKWDqpXD2e8Qz72ZPiL5kmp++r3LtajUkrF7NoernEmHhCUlql0UvJt+gwBqHdlro+5tbgVmFdQYWuVF3SxVO7txVa6Ahgnzc1qR8193mrC3gOLe3RWGE5Gp5QqdSaKMvV6LDsn8QaZNU9d29p35aG6eV0tc5NOSY1dmkNq2oV7iiRulrd1WvWz1ahEWO7eEuO5QN1O04BuArnvpm+AXQVIoQQQgghhBAywAfqLIy5IYQQQgghhBByPoyhJoQQQgghhBBCCrjgvqHOpXbypEvRKI0j1ShN0VSa8qg0bZY35UguJYuqY2HciBYrJ9FSdXlibDwypE6eVGJaew5bjEuIZ0y0srl2hPFMWnyQvJ5KhdMdHLj6sia9hUZoB1osmidNztD+HvF1Q4un0t6NIO/1xE2ndA1/9/boWPFnrYj1/TAmlvjKAS3u1lrPmP1Tuq6k5m2sttK0mmO9S8PTt6nzSSx9jPb+h0GO930VWpocTb+WhPXKlD5yHRmud/v7QCa2P7Y3luxFqTpraJUWquZ9Bp59IVUuR+nZz3PNmiYL0N8Z4Dmjae0a69xVkz5Yk2k9y2xiH23V5mL5a5VGCCGEEEIIIYQcE7r+MP45PsPe3h52dnZwLYCLI9ctf/G5DMCNsbJhuYT8VNkcpeWOisyh704AOA3/t0SHtX/k33SHdrWUmZLRquxRsJ91yYzN8RKZob0fhnZq3z2MYbPespa1tbXMdZXbhMyjouthnyct18uh7GmDjBKZnrXL8l1k7V5tWXNSZb1ExzJz1huun+j7C2ZuWs8SLWWWcBRlbmIPK5V5IdrBGGv7HQCuBjCfz7G9va3f3B9B5vN5v+ir6Gcymax8Ytd2I/fJe+VnOp320+m0341c67pu5RO7dnLxsyYjVc/JjIzU52Sk3lx/hfpq92r9M51Oi/tHfizjE9PV0s+pMdH6KyzrsR+PHbRqp8cOPPIs9Xh1lXOz1N41+0mNV0pXbWxDfXNzymoH1jbn1oNUHwx9q92bWn+sc6qk7Dpsz9K3JbpqdlDaTo+unjXII7OVHWj7SaovLXPTaget1mjP3EztqV3XLffJ4aPNTc9YauPnGU9N95yuY+wLmr1b7ckyNw/b2mUZvxb9OkY7U232rgfhPNH6x6Nv6bnCa3uHeUw8ZS1rWezMb113vTakjYmm61C2dG7O5/PssyldvgkhhBBCCCGEkAL4QE0IIYQQQgghhBTAB2pCCCGEEEIIIaSAY5k2q1NSA/RBWpXe+T62MFVAaaqinEztulffkDCFRi5FTR97Lf6CsJ3ympZKQeqeSl0Ua6On3Zax1362yAyv5V7Lf6c73Wn58xe/+MVk/VLv5PXKdwhqYxvVIZIaJaZfSJhOajKZrJTXUlbkUpV0SoqmsH/kNU3XwQ67/X1Mp9Pz9GuVaqIUzS486VE8Kay0fpYyYzLkvd7UPLLck570pJXrf/RHf2SqR6KNSaek/8gR9m0rPPK18UvuU4Y0J5qNePa/5Xgu5lhILm2dhsVOYyntNLT+yI2JtKGUrqk1cJib1j0sd03rHw3LWSa1Rrda9zQse8+AZ25G90ZDuqTc3m29VopcL712K+tJ4TnHWudxbh3xpLjS5FvXOYnUZx1pmOSZxPpsIWmVQkorJ88V4fruPeNqWOdUbmy1828L+A01IYQQQgghhBBSAB+oCSGEEEIIIYSQAvhATQghhBBCCCGEFHAsY6itcRd9358X02WNV8jF0cT882MxpbIuT1yBJ0ZCi5sujdGoiQfSxshDTeyjqV7UtTOMm5ZoMYqSUh08caypazHZWv/kYqFLsdqinF9a3KYW92/VxzsyWsyP1FWbt1p/5PpdexeCVjb13gRNRswOtLVLlpMx09/7vb+Fj33sgXjAAz6K3/3df2jWVeJ5p8IYaHGanjhI7VpuLwxleuxAGz9tPZD6aO8ByK1d1lhfDzX7SXivFhueiyNP1eklLCtlDn07OXsWW7MZzpw5k6wnHKN1xJAC6XesSDw266HVe28knnOF9r6MmH7De4E0+2r1roHcPNFsL9SnZrzCPvHsS1o9cr/NvWNlDLR9s9W7ECRhOyWe2Od19I+k9Bw0xj5/LB+oCSGEHEeuxO/+7vej6w7w9rd/C4DfAXBq00oRQggh5AKGLt+EEEKOCFeg6w7Q9xN03QGAyzetECGEEEIucC74b6g9LgpbW1sAzrlJyfRFFhe9lAus5t6kpUuqdQMe0NLdeCh1l/OUy6VDaOWqXVr26quvxic+8WjccsvX4h73eC/+9E//WfJej2ttoFjWBSdmT5aULBqe8ILZ7Nyy0u3vYzadqq6QITk7sI6tvCbduGJphbypncJ6OqetyHaGfetZjzzpkjxupRZ3/picZBhMZDyL6gHQ9zeg718I4Cz6fgbghnijIrq/4AUvWPn9ZS97WbJsSn6s3lLk2mV18VzqZJgnmsyYDimk62Mu9aImM8Qz30pTVXqQ/TGGu7Nnnmh4yqXSER0Aqru3l9L9V3PZbRXWVZTqLZGKqoVMc6rMDNJmU27LwPn7QGnKvzAV3mQyOa9eLX2S7NsQT6iL1pcW3Qe0tUyGhJXad2mYx7rCj0I78OganoFy6eVSZWPPNsl7UZ4ubR1c8A/UhLTkE594NP70T/8PdN0+PvCBpwJ4M+iSSkgbuu4U+v4qnPtm+gZwbhFCCCFk03T9uh/hG7C3t4ednR1cC+DiwjouA3Cjs8xk8dePb+57d1lNZvg3ldRglOibKif/lidlDtdPNJQ5ZrnDJPPVd/5l/O7tP4h9zDDFWTwNL8U1ePGoMiUxe6rtn5zNrMhfzJMTfY/Ti2/SLOWkzBK8ZUNbPw3fX+pbzRPL/E+VTZEar9bzpNXa1dJmU2Uf+MAHrvz+0Y9+1FSuRmZpOct8OyrzpJVMyZhryZhz87CUs5Zdx9wcs9xQVtqQuoct/i2195J9U5aN6aPVs87zZa5/LN8Xx+b1Os4H65TZ2g48MkuonSfWclLmYV4v7wBwNYD5fI7t7W395v4IMp/Peyxealj6OVlQZmtrq9/a2upPdV1TmdPpdPmR17qu67uui5Ydrg0fq8zJZLLySV3fdbYv1DWlT225VJtPRq6PZQda2W//9v/QA33fdWd7oO+BK4tkynbKPtLaGbOnWP947CdnM+FnNpv1s9ms3+26fjabqfbtsQPL2Hr7NrT1XLs880TrW9nOsH8sYzK0UxvLsM6YHVj7J2c/mk145nWsnpTM0rn5ghe8YOVjLecZE4/9aOVy8806T3LrpfUz2NHu4udW7bTYxC7O7w/rXK0dE688qw1pa7tVTst90zIOsbmpyanpn9J2ajI99iNtr3T90WR6zjIW3UvOl6XzJLcehDJjczc1r0vPtJ41umYdKbWD1H5sKVti694y4Rzz6KqNpUem9d7c2lVqP5bPfD7PPpseeZfvLpaeaqRUCkOs0UFERq/EsS7lJ2KASl81L+uxYk2p4629E/EUpbGhWtxRLjZU65NOicPwxFd1SuzHZz/7a7jf/f4at99+Ane+82n80i89F8BzAQBPfepTk3Xm6B1xNVpfa2PSKr3FEJPUQ49PqsETmyaJ9WWPeBs1m9HmiWduRuMFDWjrXCo9kSVWXNNdXgt/l2OyXA8ScXYp3XMyrSl1JI9+9KPxznfeD+9//6V42MM+g677v87XNRLXt65UQZ0Sf5aam7GxKt0XtD1NpnLp+x67u8D11wNXXAE8/ek2u83tmyE16fdK3wMi8cxHDS1FYmnaTImnbz31aJTOFY+ucr3W1mSNmnnskdMF7zeoifP37PkardavsN9z6SZja8d591TqptmBZS0bsL7DSNbpseHmaWIjMmveBxPWo6X8k/dqa3Suf0ptuvq9N5Xv6FF18xZ485vfjCuvvBL3vve90XUd/uAP/mDl+rOe9axlcPrwefKTn7xyz+c+9zl8//d/P7a3t3G3u90N11xzDW677baiBhBy2LjrXa/HpZf+e9z1rtdvWhVCyIJ3vvN+eOlLH483vOHheOlLH4++v3LTKh1ZdneBpz8deNnLzv0LsC8JIYRcuLgfqG+//XZ8wzd8A17+8pcn73nyk5+MT3/608vPtddeu3L9+7//+/Ge97wHr3/96/Ga17wGb37zm/Gc5zzHrz0hhBBi4P3vvxSTyQEODiaYTJhyq4brrwemU2B//9y/7EtCCCEXMm6X76c85Sl4ylOeot5z0UUX4dJLL41ee9/73ofXve51OH36NL75m78ZwLn0JU996lPxH//jf8S9731vlz4WlzdrSpZUfSX43DivBHAFgOvRda9J6uNxZfVQ6raVKmdx5UmNSa4NKXedIZ1LiOYO7kmLIevV3Ivf+973rvxe6uaddEcRqVykPjk016NWbkkSqyuNdHHT2ulxS5ZE3S8NKVlauQLXuDBq4QYaNe6zUfmKDEnKLTAroyBERuuf17/+X6Lv/wDAWRwczABc/yWX/4zrfylFoSQ43w6ibngGm221v0mb/YVfeMayL/f39fRlmvyx3Ou1cAwtVU+rcCxJWI/cT0rJuQSXujCuw426xg7GCGlIyehx/l6Ua7NcU1pQM4+1M2RLHVOkXKVrwzFKzwCekFBtjrUKBykNf5AsbXRhr5a0cAOeFK5Wm8nNcXn20spaw/SsIaFj2b37G2oLN9xwA+5xj3vgoQ99KJ773Ofis5/97PLaW9/6VtztbndbPkwDwBOe8ARMJhO8/e1vj9b3hS98AXt7eyuf48OVAHYBvADALt0QCSFkBLruFLruGQBetviXKbdKYV8SQgghX6L5S8me/OQn43u+53vwwAc+EH/1V3+FH//xH8dTnvIUvPWtb8V0OsVnPvMZ3OMe91hVYjbDJZdcgs985jPROn/2Z38WP/mTP9la1UPCFQDO4txQnMU51zkeTgghpDXnHgTPra9HL2Hk4YJ9SQghhJyj+QP1933f9y1//rqv+zp8/dd/PR70oAfhhhtuwOMf//iiOv/Fv/gXeNGLXrT8fW9vD/e73/2qdT0cXA/ghfjSQ/UNG9WGEEIIIYQQQoiN0dNmffVXfzW+8iu/Eh/+8Ifx+Mc/HpdeeiluueWWlXvOnj2Lz33uc8m464suuggXXXRR9FosjkFLSyHj8zxxEKVpDB760IcCAO7yiU/gofe9L1784hevXP8n/+QZ6PvL0XU3oO/X/+10afxEKn4hFpfseWV+Scohb5xmLqZUi5lqlc6ilHWl8dHQ5k2rdAiaDC0ex0Mubluzd088szXFhyeVSu59EKlyNXhizGWMlJYWKiXDq3erdUWjJPWTWk8kxY71fRkx2Z54z1idre8N25l7z0WqXNd155XVUvJpabPcaVYwqGFvs9bOsd5VIVnHnNc4DHHRoQ2V2rd8z4WHMd67kUPrk9J3xXh1sIy1d8Rz79awIsckJDc3o+lwKzG/NyVzby5dqXX/zdls6VlmjPkP6KlgSyld90eJoQ75xCc+gc9+9rO4173uBQB43OMeh1tvvRU33XTT8p43vvGNODg4wGMe85ix1TmUdN1rMJn8H+e9kIwQQgghhBBCyOHF/Q31bbfdhg9/+MPL3z/60Y/iXe96Fy655BJccskl+Mmf/Ek885nPxKWXXoq/+qu/wo/92I/ha77ma/CkJz0JAPDwhz8cT37yk/HsZz8br3jFK3DmzBk8//nPx/d93/e53/BNCCGEEEIIIYRsCvc31O94xzvwqEc9Co961KMAAC960YvwqEc9Cv/6X/9rTKdT/I//8T9w1VVX4SEPeQiuueYafNM3fRP+9E//dMVl+7d/+7fxsIc9DI9//OPx1Kc+Fd/2bd+GX/7lX27XKkIIIYQQQgghZGTc31Bffvnlqk/5H//xH2fruOSSS/CqV73KKzpKTBctfmmZA28Rh5HLWxbiiZkM6/3ABz4AALit7/GBD3wAL3nJS8wyw1gw2dbZbHX4whiFTeSga5XrVtNhrJhlT25CTz1a7utWY9SKra2tld/PnDmTvHeMeEtpPyU5j1uzjjjEMWwteW8kHlWLRZV4cvi2etfAJuZC2Le5taE0N7jsn3BMivJ2J/SzlrXEx1vWLqnPsuz+fjyfdkDKZvq+d9mpVUaOUrvVxk/u26Xt2gSeONaa/Oit9nx53tOI5muOvN/AQ6uzlXamzb17JHZvTL/cmmONnZW/a/rUzM1SG9Fiw3P6mJ4PIuUs50KLfjVYzweeeg7DmVZ790h0HBJrV4t+Hj2GmhBCCCGEEEIIOY50/SZeU1zJ3t4ednZ2cC2AiyPX5d8h+8i1EwBOA0DBX8guA3Bj5p6w1qHGodxd73KXlXv/5223Zes5EZF53l9cw7/oK7pq/RNyGRZ9ZLhXlsv1T8tyR0WmtD2tL1NjNGY7J/Kbrr4/lmOizU3r3PDKbFmuhUzvX/c32T+bHhPPetmqnWO2saSsZ+3Syq5rnmxCprVs6luUo7iOHHaZm7KD1v3jOtMa7pXXWrdT8wVYx1mmddkxy23irKeV9Zz5D/uZtkW5OwBcDWA+n2N7e1u/uT+CzOfzHufGY/mZzWbLj7zWdd3yM/zfSXGPdq/8xMqG8mM6hOUmk8nKJ5Qpr+X0Tek+lN9dyNPKTafTlY8mM5QhP1q5VLss/VOqq6WvTi5+bmUHqT7JlbPWc9LYlyUyS8vV2Kw2llpfSpmhvde0M1WvnKdyTCzjbulb69i2HM912KxHx8Eedhc/5+RYZWrtzK0H1r5NrU+1YxLTvdQGSsquaz9pNSahvpa+tPSPZz3Q5nFKj6Gd2vzXbL3VGuSRaS2XWy9Lzwdj2bvWt5Z2164jOdsLrw1nzt2uM59/a/sntx6sew+rKav1j7YGedaRseZmabnU/BvG0zrHZP942hju8zX9k3vuatWv8/k8+2xKl29CCCGEEEIIIaQAPlATQgghhBBCCCEF8IGaEEIIIYQQQggpwJ0267Civc6+X0OaDJn6olNe+iN/D++teZV8r7z+X9Mnmcokk2oiJSP2Cn1Pu7R7c6kdrKlnwj6IjblmB52SYkD2iamejH6SXF92kZQVlrQG1jq9+mho6T+0elNzyjJ7w/QNUoanLaG+Mq2JlgpHm18l8mNlPSkqrLbeRVJNaOtKaUqNwSZ6xOdw6Rpt1T3VjoGa9ekHf/AHlz//xm/8xjk99vcxnU5XyuZ0CK+3SkeirV2elIielF/aWObW6BYycnj2Zm1fCNHWipyunrZIu4jWU5n+SiM53/q+KmVNUVq4SP3avBlSm3X7+5hNpytjlNvjl3tRw/f9JlP14Uv202PcFGyh3YbrQayd1r3Ic16SaPu4h9I1yKO7dk1LiVaD9gyQSs1lWd9j5eTPFsJ9vmauWNIOD3jS2A24bNJ8JyGEEEIIIYQQQpbwgZoQQgghhBBCCCng2Lh8a+7Ope4ENfV4XH1r3FVy8mPuFJr7blhW/izLpvT2uo14yI1JqbuMx7Vdc1nSyta4uVndCWW90pXH6hKv1VmD5oIj3Uq1e4v6rqBsqIMsF+rrYemGv3C39LghxdxwU/dasfazNzRCcxNu5absweR6GHGBzekWuofmRuAv/uIvlj9L13ZtrdB0kNcGfQCfC2gr1+jDUI8HzXV0jHCx3JiUtlvat8UVsovYu6TVmGhlpe6hzGRImkGf0tApzY16XXapUWqXydCRvldDBGQ9cg/T3ItbhWO2KlvjYv3yl798+fPb3/72lWtDCI+FWIhTazz9M/RJF9GlVejIWIS25gm9k7TQ/dg8UBNCCCGHmVtv/Q7cdts34y53eQeAP9+0OoQQQghpAB+oCSGEkJHp+yvxkY+8BMBZ3HLL9wP4KwCnNqwVIYQQQmphDDUhhBAyOlcAOItzf8c+C+DyjWpDCCGEkDYcm2+ox4i9OgyxMiG5WNBouqRIjIuM2dBSsmjxJjWvpG+ViqMVsl5rHGLLNCfrqEeL15FjfXBwsIyNaRX33yot1Low2XTfZ+OZU3HtY9lPqzR1ubRZHqwx3p50Wx60OO7S+HxgNd4S6jr3RgA/ii89VL/pXJ9E0qfVrJetUud40tJoMYGl73/IYXk/haU2q321SpOTrHdhB6Xxldq9mn153qkyFp41SCMV79lVriGl50vtbFVTT6v915MWLrYejPm+nJTMgVK7rIlZft7zngfgSgBXoOvm6LoyD6NWe270HS+RdQTQ2x2+zyNH8t1JYn6O9Z4b2T+l6XnH4Ng8UBNCCCGHl1MArsK5b6ZvQNe9ZrPqEEIIcXAlgF0AZ9H3LwTwjOKHanL86PrD9jWsgb29Pezs7OBaABcX1nEZgBvXXHYoJ//GahkAr8xBxgkApzPyUvpclimrlavpnxJay7T8pe04tDMkNp7rtFlZruRbuk2NSW6OjSFzne1sratmT3LtKtmgvPZeu3bVlD0sYyLx9E/s3hKZLcsdVZmWvqyVVzvHDuuYpL6/PjGiTK1cq33TUs9hWg+Oskyt3H/Ff8Yf4gU4wAwTnMWVeCmuwYtX9Gshz1pW65/jZHubLHcHgKsBzOdzbG9v6zf3R5D5fN5j4TE5fLquW37ktdjnpOGe1mWHcpPJZOVjLRu2MdbO8NpQ9+5C3nQ6XX5kuZQ+J4GVcrKsVk7TLTVGmxwT+ZnNZsuPp+xRa2f4kWPddd3S7kpttkbXcAy0cfCOSWx8SnQd6jiJ8+eCZgdhOet65W1nqzFpqWtsfYrZk1y7xrJ369rlkWmZ/6m+tdhpzViO2T/a/hK2s6Wulr2wpUzr2NbagdaXpWMp9Rnq312M3Rj206qsNk80mw0/u5W6lp4vtX3B0z+W/bd2D8vdO8Z6eRhl6uWu7IG+B870QN933dNHHZOcvcVsK7aO1KwlHtvzzpOhbM16uS4bmM/n2WfTC87lOxeP04+Qb1f69WtxLFInT0xAH4nP6Z11SLQckLl6t7a2lj+fOXOmWActD57WlzVjqcUhdkpMoCdu5bCRilGK9WMYby2ve+wtrGdZbjE3tTHwxJRJ/WLzPqYPYH9ngCcndGyepsp51oNWa1crtFhoTdd1xeeNUXfNGHjKdonY61odQjz9E84TT55XqX84x4Zr3f4+ZtOpmg84+v6Hxsh+teZv9xL2l+alU/OuAZkDPaQmT691/82NV2qNzPVrLt+9lTAv73Q6XanXs/eM9f4HjdK9UduzZD1jveei5vyr1dPuXP+H6PtnoO+/E8D16PtT0VdD5J4zNF0964gWz9zq7Gl5XimxA+0creE5P0Wvj5gz+4J7oCaEEEIIIYQQD113Cl13auMvwCKHD6bNIoQQQgghhBBCCjg231CXfn2vuXElXR0ibhya/FZu5h6XM0nofi1dQUy6R+7NyQ/dvGvSPmj3juV6pKH1l+Yi77E1D1pqDumSE+pT4xLkKRu698lyqXr6vlfb1SpF25AeLeVWqoU4hLYX078F67Bna2oXb5vW5bqd4jCkXdOocV2zXvPQyk1Szulwjkn3Pikj/D10Sz579qwpFV2t7hJt7fKsQdH0NpF6cu2IrUeW+SXrkS7NYdu0tJpeOdb7SscrTG8JnB+qFYa+SbT1QbrEa/uAlm5So8ZGo3VH0ggB9vFzh5woulhd/00uug3qCZHjFZLsn0TfppBr01jhIetACwFpFVoqZch5bLXhXMilFsaYsum+781jxG+oCSGEEEIIIYSQAvhATQghhBBCCCGEFMAHakIIIYQQQgghpIBjE0NtTVOzjHvc38dkMnGl/AnL1rzOPlUvcH47tFhVTVcZI1WTtqpEPuCPe0jFQWtxNJ44stKUWknbMsTSW+XUpJqxxK70yMeCaPEnrdLAeChJFdIdHGR1Da8PsTpDnKaWZkWzPQ/ynQrriKHSZHpSftWgxaN6sK71pSk8cmOizXlP360jLtpDafxi7t5wjmnlANueJuuNldPeb+Ch1E5zMYGlRG2tYB2R+6Zlj43J1PSTaGt0afy+p19rUjJp/aO9B8SjT+2ZpEvYQdjOZLoy53uBtLRrsmxN/LB1HfakmyyNI69Zk63vKYmxjvfwaHjeC9RKhsSasm2sVGFW+A01IYQQQgghhBBSAB+oCSGEEEIIIYSQAo6Ny7fV9SDnqmItmyNM57CUY3DJkYTuDZ40DDXtTNXpxZpWJOe27UlJpqW38GB1K61xXSvVzzMmUletXa1chkrdZz19KV3Xwmu5VCqaTE2HVi56y1Rmkf7x9EFpSjtpB5obWSsXKk9duVRmWjs9Y5Jyl6txQ2zlFmhNTzSma7gnPERLx+fZw8J63/GOdwAAvvpHfxR//vM/j0c/+tHJcikXz3U6zofrXisXb41St1Fv2Vg9w9qlpWjyzBPNZbfGxtcaThOR2arfJdFzUuL/Q2rcd6N72MLt1pLezYIn9M2zb6bKSWr2eC2kqSg0wXB+WkcqyFbpFCWlc2GsdJwt2nVsHqgJIYQQcnx405u28St/9Tw85E3bm1aFEEIIScIHakIIIYQcKt70pm288IUPwhRfhf0XTgFcCeDUptUihBBCzqPrN/E60Ur29vaws7ODawFcXFjHZQBuHLFszJWmROZQy4mCsqUya8uuu1xYNnROsRj2UeqfTcg8rLqmHLpOADhd4KKUkmmxJ287wzl9WqlXIydT9s8gw9u3nnIp3P2zGL8TfY/TuZAB8ftRaqcsd5TWLs1xW+ru2cPCev/oPr+DX/7kM7GPKabYx9PwC7gGLy7S18thXfdalispm1u7NBs+ymeZozQ31yGzxg40man1PFfOyrrOJIdhP6HMNuXuAHA1gPl8ju3tjKdUfwSZz+c9FpmAhk/XdcuPvBZ+JpNJP5lM+t3Fz2G5XNnhnpPKtVg9YTmrDFlPTGaqbZPJxFUu9Sktu+5yJWU9Y6LJ9NiP1DUcL/mRZabTaT+dTvvdyv6R+oafQcbw0frV0mbvPAnbOJ1Oz7tX6x9tbspP6TxJjZVlTErndKoPau1gNpstP55yHl1r51hqnljGyNs/cl8oLZtbD1Jj6ZVpHRNPWa2f5ViG9tPShsL154d+6GQP9P0UZ3qg74ErTfYWsz1tTOSaZ+0fba+u2RfGsIPU2LbeNy3zNCYztvekylnnV8sxSe1DqXZa9s1Umy3949lPxtirh3m/u1gLNm17FvtJ2YHFnmIyW/WPZ0w8ttdqjfbItKzJtXPTc65oeR6Zz+fZZ1O6fBNCCCHkUPHIR34UP/RDuzj4b3+HyT/4e/iv/5Xu3oQQQg4nTJtFCCGEkEPHIx/5UfzLS/8DHvnIj25aFUIIISQJH6gJIYQQQgghhJACjo3Ld298t1onculZckDLsl0kN56Un8pJZ9XToo+sy5r3WZbrGuWZG9rc7e9jOp2qOQS1nKtaLsJWuvaZHHhaf5XK70R+QU8OPS2vqpZzWBLqK/tSGy95b6tcxV0kX2W/+Fn2raa7VUYox0uqXI/83Cy1U62d2lyQ14bczpOzZ7E1m+HMmTM++c6c4oAvt3M0f23BPFkHMs/5YP898u2MrTuDva9jjZbjaZ1Hy70vkcte0z3MKw6H3j/6oz8KAHhg8HOItQ9yfWldv2ry6YZ5aFNraWzf1MbHYyM1c8hzlmmxHwO+nOypckC7s1fuvFBSj2fflH3gWYe1fcF6TV4f7Llf/Kztf549zHI9tgZ5+rL0vJTb07X+abV+S12j/bfoH0/ua49MDa1dmo14+qPVXJR9l9rDPDL4DTUhhBBCCCGEEFIAH6gJIYQQQgghhJACjo3Lt+ZyFnNP7Rc/p9z3AN3FM0epG2xK9+7goJnrY437Scr9K/x96FttTDSZHjf8gcFdTnMzDXUfrnUHB5hMJi6XKg2tb2tcVUKXS4nHLqyu7BJPeIHE6r63tHWDe3GN7iEel2aJNjc1V7aw3GQyUe1CW4NyLp8hg/vXQd+7XMGkq2/NmIRrrdQhbKfHnV+ihUZIN9yYS2yPvG1r/dfcNVv5PbV2ebCWlaFScu3XxmwpI9IXHvfLUjyurB6XRalrOK9l/2hroMetVKMm/Egr6znLWPqvi4yxZ/1spetYdF2X7NdwDWp+5jDI1PrHE64i9zBt3npk5kKngC/tfa3OMpp7+nL/M7Szxv3YinW9LD1fekJy1HoiOlhDUmO/l+4LqX5oGa4Swm+oCSGEEEIIIYSQAvhATQghhBBCCCGEFMAHakIIIYQQQgghpIALIoY6Gp+XeLW8jBUL8aQq0MpZ4isHwrjknMxWMacallRYsXiT0lQFklTc0RC3rTFGjIuWTgoZnUpjgDw6afFCnlRPuRgXrZ5SO9BI6u7sx5r0aaHteeaiJ15X6y9PChRPLHSszZaUULk+sMYeyzHx9G24BuXisMZYD2rqjKYOW5BKLeiNN9fsQEtXKPHE+qbeewGc366LLrpo+fMXvvCFZDnAvn7m7Mc6Zrm5Gs5rzfZS14b1YKx9IcTzPg/r+2kA2/pkWS+t7fbsJzV7tYdlOyNtKJXheTfLWO3yYH1vSukZtu/7ZqmnLPKH/a80nVureay9a0DGe3vmlCd9moZ2vpRo7zuy7vG5d9BolL6nQYPfUBNCCCGEEEIIIQV0/TpeTdeYvb097Ozs4FoAFy/+L/xbg6VBlwG4sVB+aVlLOfk3k6EtY8psVXbQ/QSA01gdh1S7auR5y8b+HhXTtUbmWO0M+7aVHdToaplvXpma/Wjyw3qOwjzxlGvVTk/fxjgqa9cY82TsskM57btmOV4dysaydI2usR/PmMS+Aaodk9Pi/9ZxPlinzMNks+tup1X+OvfqmnKpsh5d1zEmufWg9Hxg4bDY+2F7zqjd40tkauVyvlOH+SwTcgeAqwHM53Nsb2/rN/dHkPl83i/6cfmZTCbLj7wWfrqu67uu608ufk5dj32Ge04q9VrKafdOp9OVj0dmrL2xctaPt+zQ/7uLn1PjkxojizzPmGg2ounq6R/r+MXamRu7VN96+kjrH9kXsb5N2WyunFWm1X6supfae6qcNkZyLfGMZ6nNaranzRNP38bWpdR6adW1xmY9fRu2U1tnD8N6KcuF60ZuvZxOp/3u4l+PLM0OtLVr+L8SmWHZ3L0XXXTR8pPrV4tNnFTscoyxtMj0nA/WoWvuHk1XTzvHWC+tY1u7V4/Rr63baRmTVvrm9pPSMSk9f481LtJm172OWPWL7fGlc2ysuVlzPtBsr1RX79lgPp9nn02PTQx1aZxmyb2xPIp9o3yRyRgJQ9600viOLhVLEInH0XTvgxgpeV8qBnDlWiReUsr09LMkFt8V0zW8Dig2EonjKc3PnMvrquXXlfSROJZYXHsqj2qsHknrvIBhnT3OjyXMydfulcTGdshjLsehN8YW5eyyK4yLlPdq64FWLhzbXF+l9Osz8cw1OYQt60qM1NxMzevDjCfWcX9/H72zDKDH71tyyQ4yPXHR2ntAZNx2Lm46RBvfZYz5/r7LDrT1UqLtmxraHIr9PgbhOtJl3qmgUfoulOS6phHRNad3OJ7y3sMcW+y5V47lGLncV+RAX0eQ+L/z6qmIgwb0GN2x5pRmp9p45eZ8KbG5kBqTkjoB47kwcjYYyw7PF23vy62tLUzOnsXWbIYzZ84014Ux1IQQQgghhBBCSAF8oCaEEEIIIYQQQgo4Ni7fIVY3pD7icqK5Zmput5pLR+h+Np1O1fQtmj5ShnSX09LSaHhcs6zuFTmXrtDdajY7Z4ZD/3jaId2drLrKPtfcWjyuYR57sqbUipXV0FyzNH1K3W6T8gtc9DQsrr9dxB1Vc7/ypLAaS3cNzY2qRp9hzgG+dWMTbtQe92ItLMeDx0Xf6oYPJFJjGdxux3IZtNY5llupXAM1t0lPeFboZp7bi2JhCyVuk9bwB4+rr2eN1tKeaX13GEIjtDEZrsVSveXG1hMqpc15zdU3qvtCV239zs1pz72leNauVDlvCFGpDUuKwhor+62VPiFjja025y3zLYU1JCzXrtIx0dbonMwzZ87gYPGvJLS90nAQfkNNCCGEEEIIIYQUwAdqQgghhBBCCCGkAD5QE0IIIYQQQgghBRzpGOowRqU0bZYnlqA0xlSmHMnpkKpXypCxj6WpeTzxVVo84zLWKZKCSNNnaEe/+Fnr95T8WHyVpR5LehSNnK2VxsNo8SaetCtaPPM64jKBNrEpOcI5lhvL1PVcWigNc7xQpk7P2uUhtwbl9BnmSU06kmiqvEg9OZkaYXxVaSyYvGYd286gp2Z7WvzwYYhztVKzp0bj/CpTO0kOWz1avR4Znnh0D57Y4jHSb8mUf573gJTum5oOWmpF+f+efaD0fTDyHT3a+m46K+T0w3gx+KXnA8/YlsYWm9+lkZEvydlBqzOk9ZpEi1OuOQ+0iNsG2q1zLc5a/IaaEEIIIYQQQggpgA/UhBBCCCGEEEJIAUfa5Tsk5Y6Soyg9gjM9ivfV7iFhSqmcXKtb6TOe8YyV3//gD/5ArTfE0reDW6nXzdXifp1Kv+VNczLoE0ur4qGVS66kxi045aYkXZpNtl/gdiRlWvso57pWGtJgSSdT6/rvWUc0pHxPGhENzY1a60tPGiHZ5qUr9EKmVXcpU7P3sdIBecbPk5onKqNxKioPYfo0SRhSJFMXlaZzq1lHJK1c/UJq3C1bpeaxuuHmdG3VJ9Y0pCs6Ra5ppNYO4PxwFU9qHk+KLcs6WIt1bnhSEC11W+y1pXuRNQVZS1qFDNTYmlaP5obv6R9PO7U0cbl6Q13H6svSemv2am1d0Vz2YzoM50tJi3BEfkNNCCGEEEIIIYQU0PVH6W0nC/b29rCzs4NXA7h48X/eRlwG4MZC+Zay4d9JBt1KZA5/cTnR981kXnrppSu/f+Yzn4nWV9pH3nKD3icAnIY+lvLvTzV9W1NukzJPi/+z2P5R6B+PHXhkpmxmTJmtyrWy99p2Fq1djWRaxk9eOwr2vqlyYVnrtzVyLM+71yHTS6pcbL8bW+aYZS8EXa1lW52fPDIPQ7mSsod9DztsMludn7R9SSuXYxN7dW3ZdZ5lPDJjOnj3sDsAXA1gPp9je3tbF9AfQebzeQ+g77qun0wm/WQy6buuW34WfaN+Tib+P6wn9UmVDT+DXpPJ5DyZsj6tntls1s9ms37X0C5NZvh5xjOesfLx9pG1b61tHHTeXfys3TudTlc+pbqGY2m1mdb9U1pW9oHFnixjkrL12v6x2sHQnt3Fz5p+nr5N2YzX9jwytfXDYwet7F22s9V6qbW5tm8HmeG6JutJXWu5dlnX63WvQbXrCPCl/SX20exHG5PW+qbKWeSvc0w85wOrrprtHcY9rHSepNYOy/mplUyt3BjrZa6stZ25dXYd/VPaTs9ZuJVM7TyQ6oOYrpY1sOTM79k3xzqzjVGuZq+2np+0OdN13cr50mMHAPr5fJ59Nj3SMdR9kJbgAQ94wPL/P/axj1XVOdClYgIr0qPE6g1lyjiDMKVUjlg9Q/ziC17wguW122+/HR/72Dfg059+KO51rw9gMtk16661Y9k/kXhULX7CE6fpiXPQ+tlTVpYLY30lrWJeNaQ+nnZp96auxf5fpjIJ0dKKaGOSswNrO3P6xOrsHfUPaO838NSlxYLW2HuIZ45F6zTEZaXsslamVnasdEBaO5Op+5y6hDK8trcit2Kds6Y2lPOkRl8r0g5kv1vnRmqfGkjF8nnbWLo+lazJ8lrvTLWk6STLhf2+vGaIpZfIM4lWrrRPNJk19Whrq1ZvqzSImq6la3uNTElpO7e2tlZ+/+IXv2iWWYpnT9XWA8seYXk3S6rvLOOpndlK14OadUSjxjatOuTu29/fR4+8DWjrocaRfqAmZXzsY9+A17/++ei6fbz73d+FrnsDuu7UptUihBBCCCGEkCMFX0p2AfLpTz8UXbePvp8u/v3OTatECCGEEEIIIUcOPlBfgNzrXh8IHqan6Lo3bVolQgghhBBCCDlyHGmX7zCG5+53vztuvfU7sLf3TTh58n/DVVet3pdC5uEMc29KwjiyHGG9sk4ZS9Aqn2Ys3mOIw/iFX/gFcfefoO8vB3AD+v5UMnWmFk/hiZnU4hBk/mFPWQ1ZLhUX4Y03CfNipq7FkO2MxQ9byo6VrzYWaxjLWwwUxsTCFxPo0dUap52T6Skb5v/Moc1xTx7FQLHM5TZxT8tYsP39bC5pTxyd1s5WscUSqV+ow/L9D/v7mE2n6j6QapdXU098umcd9uwn2tzUxsgzT7R3Tlj16fu+OC+9p101aPG6GlqsuNbmcG5Op1N1bnredyJJ2rtzbraK9fXEN7bKER/K9OjuuVeeD0rfv7KO97hIPGt9aLeemGnPeqnh6Z9SmR5bX9d7QMJ2W94rE5Mhf2+VezuHdZ/S9kLArm+prkf6gTrk1lu/Ax/+8H8CcBZPfzpw8iRWHqqJ5NTiQwghhBBCCCGkhGPj8r23900AzgKYYToFbrhhwwoRQgghhBBCCDnWHOlvqMP0Hbfc8jsA/jcAZ7G/P8NLXvJ0/PzPn/8NrHSr0Vz7YvKseOo1uSE4XRA8r+3XaOVyqblihC7U+4txCfG45Gjuch63wFAHzQW91FV8f3/f5XqouZlraHaQk39wcLB0Wapxk7TakMflzeSKvcDqXpyrN5Uipo9c87jIjxHy4aEmpZ3mRqbZ3lhuuJrbraVve/jW7ho8ru2esS21Ic0Olv2aSGWmuctpa1fKHTQsl8KatkayrpCZFKm9cOhbbU6FZeV+4pHpSWmnrU+e9HIlqYNy5FKihWm+PDLk3BxDd4kcz2i6ssTvsXoGLKEbXWSP97jWatSsByn34pqQsFZps1q51mtpGGW4nWnfjISu1ejXIqWkt1xp2GdN2FmLZ50j/UAd0nWn0PdPB3A5gBuYBooQQgghhBBCyKgcmwdqAIuHaD5IE0IIIYQQQggZn2MTQ00IIYQQQgghhKyTY/MNtdU/Pxd3dMMNN+C///evwDvfeTf8/u//U4TfeGvxzNJ335rWRFITrxuLN4nFSLWK+alBk1mamieMqc+RS4dg7ZOauIuWKYFCNDtoFQdVihZ31CqtSo5WscatUkh5YovC9E4187gk3jOmpyXOvU+UTcmRaOteqg9aprAaI9YqJ1MyVvqPVvPMNH6R2D75e6sUP54UlyGed05osaGedJxy3fOkErLi0UdSuq4k4+wjdmB9j0xuDDzv1vBQWm/N2lGUTtEpM5wnnv3No0PNOcO6Jo4V26+918XTP9qYaGkYc++D8bznQiNc9zZhszVz0/PejZAxzt/H5oG6Ff/9v38F/uW/fCQmkwMAuwCuAt3ICSGEEEIIIYRIun6sr8lGZG9vDzs7O7gWwMWG+8O/kwyNvQzAjZF7X3uvV+O/fvqZ2McME5zFd+OluAYvXrknVlb+LSbWqUM57e82qcFI6ZujVNfWMluVS+ke61uLYZfqWlP2KMlsratnnrSS2apczvYs99bKHDgB4LRBhkXmhTImrWS2LlvaznXqOsgf7K7k0HAUbK9VO08XfMszqv0k9Dlu8+SwyDxKug5lW+0nHpk17fSe9YaynnbWrgdHZe0Kyx41ex/7zH8HgKsBzOdzbG9v6zf3R5D5fN4D6Luu6yeTST+ZTPpFX5o/Jxf/DuW/VM+V/Tmf7jOLf69clhnu2TXUP51Olx8ps+u6lY9V37DOsF5LO8PP+W1evT7oFSur1TPotbvQtXRMUvqE4z18Ql2tfQmgn81m/Ww263e7rp/NZuq9cry0/knpF+q+u7jPawNDH2kyUnXF7N0zJqk+iMnTxsSja8nHMiba3JQfy3wb2unpI2s7U/XE7EBrs2c8U7busdOcHbSyPa1/rH1Za3vhvG61Rlv6trRfU32r9Zcsp7UzdS02T3Jj1KqdpXYQtiO3b1pl1tiB1j+l5wqLDMv8qmnnmHPa2rebLldq7zk7aDUmLfunpOxY68E6yg3nzeET3pPbqy190nXnny+1cnKN9jzbjGEHOVvTzvyeNU/rn1w98/k8+2xKl+/zOIVzbt6XA7gBdPcmhBBCCCGEEBKDD9RRmH6LEEIIIYQQQogO02YRQgghhBBCCCEFHOlvqPsgTZL2Cv1SOsdr3z1oabN68fKSsC2edsnX/XvqkTqU3GetAzg/VYks2ympOKTMMC2TJaUPEqm2usK0D5Yx6rFqu15yMqJ2W5BKQcM69r1IdSLTZoXpW7SUNRJP6gst9USnpGQB7GkYSsdS6iPr0er1tFlSom+ujOw/aQdWcmNS2tdaOS09Ss7WwrRHOXvR1qcwtZFMa5RKN1e7dlnnsRwTrZ2mdTei67rw2E9p6iDNZrR5kiN1b64OT9qsornqLFvTBy3K1dBKd4m2XkqZpXtGqT6S3F6trWXhWiKx7iE1bdza2lr5/cyZM8V1peod1o2hf7R1pFU6t+Hn3lBnSp8e+bXCur9oKVKBVRvKjWcytVjfr6y1lnqG/hljHvMbakIIIYQQQgghpAA+UBNCCCGEEEIIIQXwgZoQQgghhBBCCCngSMdQh4Q+9p74Sk8ccBijkMMTMxGNVTPoY5FvievT8MRFajEc2piEMYixsdL6R+pgbatHpgetnbLvWsX9W2NBxoo3y823UK4WuyfHxGIzLfSL6RnDE3PTag3S+Imf+Am8//0PwV//9QPxVV/1Ubz61f9bkXwPWh9ImcM1S0x8qs5cjLBWNjde4XVtvdRi8FM6ltyrzQ3PGj7GPB/a0S1iqMeK0/TEw1nR4k+BRHxz43aGjPW+BY1W81+izSnP2Sq1doj/HG1Mcnj26q7rmuuqxUnn7HuM/sqdn8bY7ySl5ydtnZVo64Hs5zAW22TPBTLXQW6/s5J7D0BoQzWUrm3aGlRa57F5oCaEkAuJ97//IXj1q69G1x3gbW97LIBrwXR/hBBCCCHrhS7fhBByBPnrv34guu4AfT9B1x0AuHzTKhFCCCGEXHAcy2+ox3Jv0l73L4mlxkq5PlpdDdbhyjMWpSlrPPVsgpxrreYCN5adRuUb3IeibkqGcrIdnvHUdC12uxFpHzT5nlRdNS6WWrqkUjfO7e2b0PePRdfto++n6Lo3o+smUfkS95pjsAMtFUdLWy9N61fqhlez7kqZNeE3Y2C1g5yLp4Zn37SmR9HuTcoP6krRKjXPWPu4Z60YI5VojrFTNnnavHJ/JAVfqa7WEILavgjr1daRnM1a7UCmOdJCtzRdc3jSZoW6a6E4NeFY1vNmSUpLS/iaR6aHkj7pDg5GS626jrN7UXhP5Fopx/KBmhBCjjsPeMBf4IlPfDk+9amH4N73/iDe8Aa6exNCCCGErJuuP2xf+RnY29vDzs4OrgVwcWEdlwG4ccSysb/XnQBwGucH4Yf3pgajVN+x29mi3ND+VP+MIbO23FD2tPg/i+6HdUykzfaF8mrHs3pMPC+NWvw7tu3F5nhtO//m/vdf+b+bb775PBmxcjcm9MnJO4w26ykbs++jLLOFrkfJDix9GSt7XNfo3DpylM4VreZJqp6Wtqed34brh6l/rHbQcp6U2p72PXerfXOd60Ht2rWuuRmegw7DetCqXIu5eQeAqwHM53Nsb2/rN/dHkPl83i/6pvhzcvFv13UrH63McM9JQ/2TyeS8z+7i/7V7NX09usp2lvZRK5laPdPptJ9Op/3u4uea8bR+wrG0tismU46x1u5WY+LpW087ZVtK+6d0PFuNyWw2W/lo/ZObm61sb+iTsD9ia5BH5rOf/eyVj3UdkWO9jjFZZ7lU2Zh9W+amdQ2MlQ3HPTUXNtk/VjuokenZN626evTVxj01nq1tz2JP3nNFrpxnPdiE7aV0Telbcu6S61fpWUazn5juLfonlFGzjljtQMrwzBOtT1L2b7EDbd+M1WlZoy192XqelK5drezHevbbrZRZOiZjydTmpnc9mM/n2WfTI+/yPfjBh/7wnvjFfqQv6PtIHES/0M3jux/Go0pdx0qNE1LTP1q/h+Ti80pjwbR4ilQ6KwtDjG63v5/VR6vbGlcrKjRq6UfqurRbZ/yiJ94yNbaxfrPGD8q0GFp8V05XrazHbsK6tRhzTz//yq/8SvJa7B0OgC1WPGWXtWtlWK8nPk/G9oU6aXFiMpbeky4llJmaFxbkvG4V1zqZTJZjqemT03UdsbWe/tLmuFaPZgdyLhSlzcnIz6HZfhhT2jneVyHLPehBD1q59xGPeAQ+/ekT+Nu//Tp85CP/FdYMAJ7Yy1aU2uE60hNKOVJGaby8tsdLO5C6h2WXZ+DE2q7tYWHsbG6+RW04YbM1a1KI+/0rBhlaDLWsZ9k/kb1akyn3+NL3JtXg6efwGaWGVuulh3Cf95z9xni/yZF/oCaEEEIIIV/i058+gRtv/Jfoun0AVy0+fM8CIYSMAdNmEUIIIYQcI/72b79umQEAOAum1SOEkPE48t9Q51xDAd9X+a1cFjwuJ5qrq9X9qwaPW5KmT+gKPXOkS9JcmwC9nTLtUaiv5t7vSZeUchmM9YSnvzx2WepCletbaz0etzbPdY8Nm1w+I+lRNH1ahVHkZKbGYSy3qGT6IeXaQNStLdGvmmutlFPqUmUOhxBI9y/NdTwnsxWt1uyDg4NkCJHHpjR3uZCcW7I2p8KynjHwuEKn3FO7/X2Xi7dWr6eftTNILj1RiW593+PDH/6wuOO/4ty30mdx7qh3g0lfy9nFsm960FLarct1VOuD0tCXFvs2cL6NxFyGU2t7TbhdSofc+JSeoz32dKc73Wn58xe/+MWkfKmDth6kxr1f/GwNBZLlcnKiujtTvcm5qcnUdPecZbQ1umZfMoV59fn0qtG9aFGuVfrSkCP/QE0IIYQQQkJO4dwD9eU49zBNd29CCBkLPlATQgghhBw7ToEP0oQQMj6MoSaEEEIIIYQQQgo4Nt9QW33etZQ1uXpK/epzPv9a3EEY4zJWOovSNss4hzC2WMap1MRIabENnhigWD394ufSWBWJpb9SqRRiMgbCNBUexopxiaXtSNWjxdmWytfQ4jvldU88jgdNpmazNanwwrIp+bFUS61i8Jv3nSEliycmd6xYzFDfJvXAF9uv3ZsbE2t8sbQDqY81rVDpeyO8YxfGMI61b5bWm7PRVu9x8dRjjQeX+2Yp0n60VKLamS2XImpd8dfn6ZBYu6ypRJf1JAjb7Ylr30T/tHpHj+TMmTPLn3P7ZmlcssT0zgdnndoeVpr6KrZGW/fnnMzUezc8addW9InIs+7jfd8XPb/k+ie8lpMRwm+oCSGEEEIIIYSQAvhATQghhBBCCCGEFMAHakIIIYQQQgghpIBjE0NtJRdza82nmUP64Ie0yk3oiR/0xNVZSeZxW8SpaH3ZKpdjaYywJ45Gy+mrxQTLslpuwjAuBbDHNuaQ8SYm+16tIJsDVvZPGPM2mUzUmKBNvAcglkuyM7TTYzOl8eg1+Y/DcUjpGlv3THmdE/1Tus7pouw5Tq1rXgyrvWvvf0jpmCpbGvuoXRtr7dCQbdZkhuuBRJtTY+U8Ls0nPVbs9fB763Zq+g420+3vYzadRt/xEKsnLDedTottLffuiNgcT+X0TekqycWUltpBqt5YfZ4zSKzfB2Kxq6m49lY2XLqnrePdGjVn4yIdIjJLkbqVrnvLdaSP51luRas5XzpXc+9YKdXHek2D31ATQgghhBBCCCEFdP0mXoNYyd7eHnZ2dnAtgIsL67gMwI0jlg3/9jh0cGuZ8vuV2EAO5WL6lMj0lPPKHHtMxpB5OnOPNiYh1m9N1t3OknJDS07gXP94F5h1zs2BUl2tMluW24TMVDnLHD/yc9NQrqRsq3lS8tbaTa0HnrK1/QMcjbm5ifVysJkTfY/Ti7dSD2jyZbmS42PtWaaE2HrgOZNo61xM99brpWWOH6b9ZNP7Qsqeau3AyzrPT8dpvRxzPfCWuwPA1QDm8zm2t7f1m/sjyHw+77HwcIl9uq5b+YTXJpNJP5lM+t3Fz7LscH0ymfTT6XTlE5bVysl6Bz1OLn7WdE99ThaUqSlXUra0nTX9I8umxiBXTrMZrX9kOc0OWo2JtMtWYzmbzVY+reynpF9z98h+DudmyzGx6B4ra7EnS/+kdM/1kbSRYUx3u66fzWbF88QzJuuwg9RYx9Zoz5h4PprtedppHZOhLS32k1Zjouke2lBpv2r1xnQf7D5mB6XtjO0TMR1y7Yyts6W2p5UrXbss9bQ+V7Sam6VjUtM/LcuFZa1zMzdPLP3Vem5a2ynHy3K2KbWfdY6np39S60msf1Jy5Bko9v+W/rLItLazZkxarQexPii1gfl8nn02pcs3IYQQQgghhBBSAB+oCSGEEEIIIYSQAvhATQghhBBCCCGEFHBs0mZpaaFiaXJi5eR1LV1SJ14SoaWBkDI9dOIV8SldV+6tlJmqU9YrUxNor5q3vAbfkrpI0iupEzQdQvmt+krWm5Jfmx4lma5sQcv2WGR40pG00lWbm7k6pQ4LRaK2N0Zfni863T+tbGQpC+fSXuRSSsV0y/VFMh2XM6Wdh9R4xWqTqWfOnDlj0jVHmIpRW5Pl77K/tLGO1dNF9gREdIjWY2hnaCPDWj85exZbs9lK30ndc2nGrORSXGr1hqmWcmj7ZnStSNwbru+afctrcl/wzDmrrp6y2hooddXqGSttT0oeMN56PcbZKodVTk0q2FL7qpGpybekQYzNE02+lONZkz14+ielW+6a5XwwyNT2+Bobjp2jY+00n8Myqd4sdaXwjGeqv/q+N8vnN9SEEEIIIYQQQkgBfKAmhBBCCCGEEEIK4AM1IYQQQgghhBBSwLGJodZ85WNxGZbYBonm839e/cbYNCAeTxyrJ+fHP0ZsjyVOzVJO62tPvImMgzx79qwq16pDq5gNTb9QRtd1KzHouXgzj+1ZkXYo+3IymZjilTzzqJWNyvh9T7xeSoe+77P2FdOh2993xS9qcaxyTMaKQxzjHQtafF4udm9ra2v589Dm2ncNSLSxrHmPQ6yegdw7O6zE7CK1XmrrSmlM/NCuvu/dMYFh3+betxDOP228JLl6Y/qk9E1h3X9ztaX2rGE8tbWkVTysxHpe8cTOpurJxZgn6yyYm2FZj41ItHf0eN57YYrXb/y+nNJ3V3j6q7Rvc+th7F03w7sqSu29Zo/V7CDaz4ux1GxkrHcjle6bJXHbLeSMIcNDC5n8hpoQQgghhBBCCCmAD9SEEEIIIYQQQkgBx8bl2+M+a8Xjfm11pYm5qlh11173D7Rzk2jlXmxNR6L1B7DaJ6n0ZF73UM29SurgsSfNTTFM5eK1Uc09RvaX1VUy11cHBwfVaTG0crKsHEutXbL/wrI5mSn5gG8OaemSNBvW1pFWKdFSa0VsnnjGxJsaI6WTLCfTMAFlYTkaFhczi8ya8JBwfMOQgel0qqbyi9l7C5f40E61sS1N5RTWa+nbsJ25NTomI1ZWUmPvGtY+qgndCl1Oc3tI6R6mnSukzZaGdrVKjVnjAuuZx57wNo1W95amjBpL11Jy8ysMBQr3iL7vzWuXpGguLNYga3pA+fNY64EMIwTah0ppMrWQpk24ba8j9EeVX10DIYQQQgghhBByAdL168pS35C9vT3s7OzgWgAXL/4v/FuDpUGXAbixUH5p2VQ5i+6xsvJv9rGyh6md1nJau1LfU5wAcBq2sY/JlJSOSY3M0rKWv7QdFl01hlYMY3neNyXaX2qDsjXzxHJvqmypzBJq+9Y6T0rLhRwF29uEzJq+7ZRynrXLum8eJzuw7C+HtZ2x8VrnHib7RzLm2esorQdHSdcWMlvtm5JJcAYY9n/v2uWVaS13XPb4Gpmy3HEckzsAXA1gPp9je3tbv7k/gszn837RV8vPdDpdfuS12Oek4Z6u61Y+WtnUvRaZFt1PRmRMJpOVT2k7U20pKRvK1PpD69ewP2SfyDYPn93FtZI2yn7tuq54TFrZnqfsbDZb+bSUmSpnabN3nsix3NraWvloMsOyqWvDR7M9y5yyzBPNhj1j4lmDtHLaPPGMSY0NbXqetCqnjYlnPRhsY3fxs6d/tDGxrl3y3lZ2UGqzsbLaGm3ZX2IytTne0t7HKBcb29pzhXX8YjbrWS/X0T8eO6g5s42tq3WNjMlsdSbx9M9YdhDu/7Kcde2qGRdtTDznirFsyLrH18i0rLsxO2jZTms5zzORd57M5/Pss+mxiaG2xkV0mbisvjDFgHYthyluOhKH4ZHpiW2oaUuqHi3eRMZlaXGkckzCuGTZLi2OdRkrt7+PyWRynkxtTEJ9S8bAEuOS7K+IPE96mVJqUo6EyPHrIvE4/eLnWFxtirCsxNLPreOONBuWNqNda5VGS8axWmV60uTIenLxliHaelAaty3nvyzXyobDej3rgXyngifmVXu/QTQOOaGfdq+Gth4k7dvQN2EfhOtazZ7kWbvkGhTiOQ9o5OrR5pTnHSulOmn6SJstlelJe5g7s4VoZ6SaftcotYtW60hunW2hD+A7Q7bqy/AMIPdqbe1K/R57x4qGHJOwD0y2ZrBZeT31nqAYqbRiY757JHoej8SY16yXpefNVu2W42zVnTHUhBBCCCGEEEJIAXygJoQQQgghhBBCCjg2Lt+au1zMRaEzuHzXuA/E3DRqU3FobtOpe2Myx3Lf1dwitJQVuXRSYb0el9dW6dNS9fbIu9nF7MnidjtGCrSu6/zuVxFXHslP/MRP4P3vfwj++q8fiK/6qo/id3/3H54rH7E9a7uke5WnrAc5Jh5XRK0vS+uZzVaX5FJ3/tw4t7I9y5yPuaBp5TxupclrDjctL54UTRKrO6/XtbX2vti9VlfDljq0WrNL93Hp4tkq9ZTmzusJO9H00eZxbj0aI9RNqyfXlyn34pZz2tNOT79bU9ppoREe3XLnJ5M7v2G99NhBaViONe2aNwwodIeucUX2nF+0+q1jkjt7laL1Qa5/tHu1cp7zXPPzb0QnzZW9VP6xeaAmhGyG97//IXj1q69G1x3gbW97LLrud9B1pzatFiGEEEIIIaNDl29CSBV//dcPRNcdoO8ni3+/c9MqEUIIIYQQshb4QE0IqeKrvuqjwcP0BF33pk2rRAghhBBCyFo4Ni7f1hjFmlfLe2LlYnWXpJ7R6tTiLbV4E0+7tdgrTxoKiSetgifeRNMnRItnzpX1xB2Vpo/wpM2yxol4dPXwO7/z/QBejb6/HMAN6Ptd9L1tjnliebW0HWEatBxaPa1i9Dxps0K0dw3kynrQxiX6zolETKCW0k6LfdTiqeSc9vRBaAc52wvXtuW9Be8a0Ch9D4BprhakEfK8UyE2JrF0UjnCGOEcY8W9W5H949nvrNdS+3ZsvTSlflzMTUucbQprrHjNOzk8xN75EmtnzTsCSvWRdhBLbTiMZUnKtuFnbW31pGiynGU6Q99Y1t0B6/sGit5LsGhnKNNTj+ecWpryqyYeXbvP824WT73hHGuVLjCXDqwVWr+va30YODYP1ISQzXEuZvpc3PSGz8SEEEIIIYSsDbp8E0IIIYQQQgghBfCBmhBCCCGEEEIIKeDYuHxrfvRazKRWj2Qd8RRaXlWJJ0dtaSyvJw9vaTxzLi4rHD8tzrYmRliLG6mJy9BoldexlV2m6pHxXPLemjjykljDGGEuTomMO/LEMGt43qmgxbyV5szVkH031OvNj5p750RpHFurPMapXM6WGZHS1xtDFv5ekzvdk/N4OS6RvtHWSy1O09rP3ryq4fsqDjtaO2vegRHaQW5sw7607L9DXHtpTmiLTrFy3n1BWy8t9VjauQ5y7/qwXiuNr87hOcu0mpvSfqxnbjnu1vdw1Nj7WO8l8cSYx94RcF49lbHiklI7KH1HT65fh/2u2993xYbLdyrErlnqkaSeD1zrvvlOQgghhBBCCCGELOn6Tf+5r4C9vT3s7OzgWgAXG+4P/+4wNPYyADcWyi8tS5ll5bT32NaO51Hqn03I3KSuJX9Jjskc035qyo4p87y/ti767gSA0/B/I2GZm6k6D2P/jCXztPg/Sz8v7b2wnIRjsnmZNXZQIu+o9c9xl2kpJ/el43SWKV2DUn0SK+ddL1My11FOa1fODlrtCxZqx8TDUO9wJsnJsJSTtND1DgBXA5jP59je3s4IPILM5/N+0VfLz2QyWX7ktdjnZOL/u65LfnJlW8gM2xG2pbXMMcsO5WJ9F/vMZrN+Npv1u13Xz2aztcgcq39SNgOgn06n/XQ67XcXP2u6euxAk+npH1nPZDLpdxe6WOaFpX+GsR4+rcZk6Kddw72eOa2tK0MdFn01maV9q92bsx/rPAnbaLGZdayX1rLDfBs+Y8kM+yjV7xaZrfYwbXzCeSLntUemx2Y988QjUysTrrVyzfGsl6X6SsLr0kbkvmBpV/ixlMv1bW5Njo1lbt/y2G2qT8J2xexAlkvZ5LrXIMt+kvoMc7O0f1Jj5t2rNd1b2UFu/DwyW4xnq33TMyaazco+8MzN0vOBLCfXG61/vHtY6zlm2fNL9hMA/Xw+zz6b0uWbEEIIIYQQQggpgA/UhBBCCCGEEEJIAXygJoQQQgghhBBCCjg2abNK0810I71CX0N7hf465Ldqc64erd5YKoC+710pRbwyY/ItaYQ8+miv7Q9T+sh2ynpapU+SaP0Tu9Yv/l8r57En2S5ZdlFBNH2aVs6T/qOk3hyynKdPSuefp58lWiqOLpFeI6envN4FaXLkeHrSZHgIZdaspak+iBFer5m3YdlWa3RqfexRp2ur9UCipQ7z1BPeW1OPxw6+8zu/EwDwFe9+N6644gr87d9+C2699Rtxt7u9a+W+VL/H9oXz7lFS2mn9nptvYUpCbS3LnVVa2Wl0LizWkZQ+OaJ7TUIHmdInXC9l+kbrOSen76DfsOdubW0lZXpSUWlrfXgOytUTIu1Qsz3tmmyHtFMtbVYpmj7ePa6UsB4tPag8e2nzONcO67zR5qK8LudJqE/LZyttHQ6vec4Rsh5PeuUUx+aBmhBCCCFk0/zt334L3v3unwGwj0984n8B8JcATm1YK0IIIWNBl29CCCGEkEbceus3AtgHMF38e/km1SGEEDIyx+Yb6tBtQrrHaG6lpa4qEqt7DKC7E4RuPgBw5syZ5L2l5NoVulhp1LhwJN3e+t7s9lND6CLc0vXR43LicSf06KChubWk3NO8blCaO73m8r0J1ytPvbJ/BrqIe7HmlqTVa67H2X45Jpqdxto5uHRp7l/SdU1zJc+FPCwqd7lphvV0fW+27/Da0D/rCL2ReNaDyWRSHa4y1BP7GTh/H9XQXLU9tHL9D92h17W2vulNbwIAfBbAJ/CbAP4XAGdx7ph1w/K+5DpiGM/SsADZr5qrZmkYlefe0pCYXPhRC91iMsNzmCdcxbrf5WSmbCZWj9RPm8daqJTHDlqFDbaqt5TcWabU7Vyzd8+aV7M+jhHaKcMYW7hNx2hle13XJUMKU89+nvqPzQM1IYQQQsjmOQXgKpz7ZvoG0N2bEEKON3ygJoQQQghpyinwQZoQQi4MGENNCCGEEEIIIYQUcGy+odZiC7S46KK0C5lX0st6cymawpgXLd7Fk4JhiGfs9vcxm05d8XClceQST2xoSKs4Og+bTp+2rjZ70iVo8SYWGZb49LDemlRmpbHFHrR0Nzmic6ogDYz1PQ658dLujb2zIJXSJ6wn9+4Ka/xgTVxdaHu5emJ1DjG3MbuUMs7Tt9L2Nr0eaPvS8lpiPRgrzZ+G1Z60crl7S/G8myWMQzxYrH0D1vV6EzH/MTyplrRyrWKxtbRQWiy0toeVvidF6pdaHy3vHvHMzVQ5YMNnrUg8/DreQeNJl9TqXTuevagVct8qXS9MKdoWtqfdq+2j2nuTVuRk9Mmx3Ocj7df2fGt/8RtqQgghhBBCCCGkgK4/LH/adLC3t4ednR1cC+DiwjouA3Bjw7Ly70995NoJAKfFNVk2NRiXLcqmZEiGv+ic6HucFn+11HSVMkv6aChnaVcLeTVlNynT2z8tZK6rXEnZ3DwZQ2ZtuRYy12EHtX3bon82vR5Y1r3ScqmyFkr6p8P48ySmz4W2Ro8hM2VP65wnh2E9WEe5sJ2t1gMLY4+JNjctZ9FUWS9HxQ60stbzd6u1XZNz1GVqaLaXe7ZpuRd5db0DwPcBmM/n2N7e1gv2R5D5fN4v+nX56bpu+ZHXYvedXPxsuVd+TkbunUwmK5/Ytd3Fz7LsdDpdfqSs4Z6TGRnyM5vN+tls1u92XT+bzcy6hp+hj6x9G5aTciz1xPrV+iktO5SraWepzHDc19VOr71b5kkrXXPzxKL7mP3Tqqzs21Z2oNmv7Fvt3tT6k7OZXDuta5csVzo3ZTlt3dPsPbdetrI9jx2UzhOPzcb2pdR6YBmf1nOzVOY69iJNRtiv4VjH9s1WY5ka293Fz2OMiXaWaTUmuXLhuqfZd6oPxjxXpNYny7zW5qbWrpzttbID7dNqvfTuCSl9rWfhGl3lHlI6T1rJbNVOzzkxtY+exPl2qe3d67BZ2W8A+vl8nn02PTYx1Fa6IE9pF8lDreV5LPXdl3EYsl5r3IhH/hDP2OP82EZPPX2FA0PXKO5hDIZ835OzZ7E1m7nyfWtxWZJOifPxxAt5ZIZo+UatMfl9JB9wr8SbeHJvxsr18NtLOK9zhPmSl/2RiD+z5tf1vN+gF7FMvRJXl4rlidlBq77V6tHsQLK02UV+Sq3/UjZSs/7IsvJ3TaYnn2aNjiGe9eDg4KBonrTQR/bPoM9AMv7M2U+diM+T9ZbGf7Yar1IZuTGzxiHWjL3MH2tFjokkbHcyLjKzn3hk5sYyXPda2Y8Hj61p50TrmbHv+2TOca1cTIbUXbM9T7xuq/l32OoJkTbr6QNt3fPuEVkZHn0iv1v31Jw+sl2e85Smq2dsWzyvMIaaEEIIIYQQQggpgA/UhBBCCCGEEEJIAcfG5VtLPRVL39Qj7spqcmfo+6r0Ax43CY1SHUrdKbwUu00o+rVy6Rhs5KDvXSnFQn1ikmNucC0orVdz7cuNTxekzdIw1bNA2mzY9zk3KWt6ixxhP0jXtLHCMSy6A/k5PegXa6fVtc97b4hnvnncStfhhuuR2WrNKWUTMjU8Ke1auRrKuZmaC7myck55XBE1kvIzY5UKK4mF5UiidlmQ2lDiDW2xhHFYU5nm0NyHw/CdmMzw/ppzjrZ+e2w6mu4qgbWPcm74YZ9oulrd52MyW815rexYa6DH/dqqQ03YUm7ds6I929SMV6o92nktJ7PmmcR6vpSMkUKO31ATQgghhBBCCCEF8IGaEEIIIYQQQggpgA/UhBBCCCGEEEJIAccmhtoadxSSi21IxQR0ItUNoMdphWlDcqkmWqHFfowVM+2JBdMoip8wxLho6YkkWkxZKFOTUaOrJIxH9VAjc/m+gUgZT2xTOJ6edFJaKg4PuTi7FjJyWGOWPHF1Wrx3Lj6oVcoYOUYh2rrX6j0SEm1uJu/NyMzpU5PWp1Tmulmu7ZH3hwB6zPkypd3BgTruQMK+C1LPhORs3WoHHhv24ElpF65lYXyg115k31rXg1Yp7ZL6KNeG+P0Q7/tPQmRd4e+y3tL1ofSdHB7GGpMaWr1LxtO31nIa2r4p37FSc9YL5bR6p4NkrHRlpfIl4Xs5WqXH9MyvMeYiv6EmhBBCCCGEEEIK4AM1IYQQQgghhBBSwLFx+S51GdRcMVJphiyuWSl9cu6zOf1i+uTKrcvVw5MmJ0S6imsuMFrKkVwajxCZ/kP2pdUtuNSVtcZFT5JzUwp/DvWRuss+mEwmUTe72L1WPOkRcvql8KRO8KQD8lCaHqgVyZQZCxvQ0gyWuvPnUrJ40xyVhI4s3UMNfdqq30OZNXVqqXks8gfGsKczZ84AAA6Cn1M6aGug1FWGY4R159bL0tRvY6WNDHUsTf1Yk7pI0yfphm8IBYrZpeUMpJFzCY71Sa3MHNo+UTqnWrkle9yLLe7zA6Vurx6brVmfYmePYa8e44wbOwOlZFrncUy3MdyNJaZwmsg1z3jWhG6Fa0kuRC2sa9gzuv19zKZTc0ihxBqW4LJX852EEEIIIYQQQghZwgdqQgghhBBCCCGkgK4/LK8FdLC3t4ednR1cC+Dixf+FX95bGnQZgBsj/2+pJ1W2VOaYZY+CzKHPTwA4HbmujacsazXm0nIhh2VMpONKrC0l5TqUjUmNzLCc5d5YWanvGPYjZR4GOwhJuXQt+9YZIrPOdaRmTMKy6xqTVjJb7WEemesop/XPRIZ1RGyx9V5dul5a8a5BHpmxNteOSW6OtZI5cFjWyzHtoHYPaylTo3Y8vTbrlRlryzr36trzwXGYJ+uQedoRFjCcXU70/blyobu6UZ5H1zsAXA1gPp9je3tbv7k/gszn837Rd9FP13Urn9g9Jw1lU9dOGmQ8+9nPXn5yMieTyfKjydTKxcpqMi2fkxEZ2qdWZq2uuXs0XS02YxmTw9BOrVzOXqzywr7y2IHs51ifl4zJWLZnXQ9y7bTK1Pon7OtdZ/vk2hVek+M3nU6Xn9ls1s9ms3636/rZbKbKCMtNp9ON2EGruWkZd/mx7Atj2Kzsd4t8r0ytjbl2hjab27Os9iPt1tPOmvOBdVyGeTN8PPaj1R0bZ0u5sWxvHWU9a5BHZmq9ipXTzj0xe0qVG2NuynK5PSS1n+TmhbZGy77M9au1nZrM0j7S2jnWmbaVHaxj7fLME7m2t5K5jnKWeTGMFYB+Pp9nn03p8k0IIYQQQgghhBTAB2pCCCGEEEIIIaQAPlATQgghhBBCCCEFHJs81CG9CGgPc11quQZjZVPX5H2dCKr/e3/v7+FDH3o4br75QQD+Bl13CkOeQFlWk6nhyblWmuO0Ju9jaZ7QEhmWnLXWsQVWx/Pyyy9fufYrv/IreMMbLsaf/Mx/Bz7+GwBORcvJ35vk7ax8h2CprWn1eOqU/eMZk9J6xiKUKfNlyt/DdUez2Vw7huu51sr8vqF8KUPaZSxHdY/82umxb6lDKHO4lsoN3ikvVAt/r7ERbWwlg5xuf1+d/7Jebc2R5bS+rdlPtL5M1ZmrP9XmHnkbCedCbm2XckLCshLTumLIz6yRmysa2l6d6p/JZOLqn5o1e1FBVf/IvLPaHPesQR7kvNbODu78tov+0cq12sNyNqvZUzg3rXtPjFbnu3Xs61qdSTuM5PhO5axekWHIES+Rua9DOZY9I7VvaoQyJZZ5MaztnucM2c6Qu9zlLiu/f//3/w4+8IF746EP/RRe8YqnnvvPyjWo9OypcSwfqA8DH/rQw/Hf/tuz0HX7AE6i758OYHfTapEGvOENF+OHf/hemOIfAPj/ALgK4UM1IYQQQgghpJwzZ56CX/zFJ2MyOcAb3/j1AK489wXlIYQu3yNx880PQtfto++nAM4CuHzDGpFWvO1tX47ptMc+OLaEEEIIIYS0Zn//2zGZHODgYILJ5ACH+bx9QXxDHboJSRcO6Rp55syZ5c/SDcHjdnfTTf8RwEmce+CaAbh+eZ/HrWXpxhEpV+MWeJQI25lzv7TW43Fvuv7668XVfwxgFxOcxQFmAG5YXpGubJq7jObi2SosQLIOO9BclrR2elw812XPVjly7mlzcWhXjzpXOc2tW7pGamMiCa95ytWMSdgPwzgPboia66rGWDaSmpsWl+bo+hVxXfO0uSaUJETb7+S+qZW1rnkxPGOmyQnnmAePa7upvwzIPd7qJpxbRzz2FHVXTfye+/+cjO7gICsjFnJhWYOS7YzoGp71cpScHXJr17rCr6z7b47YOSy1V1tdfz1nbE84hqdeDdm32pxKyZDlJKkzo2U/idVrcd+XhK7bEs1makJkwn1TyrjtttuC+16Pvn8egLM4ODj3LBXOMQ+TycS9jnhkXBAP1Jug604t3Lwvx7mH6cPpokBKOAXgKnw3LscubgDHlhBCCCGEkHace5a6CueepW7AYT5vu77u+9mf/VmcOHECd73rXXGPe9wDz3jGM/CBD3xg5Z7Pf/7zeN7znoev+IqvwF3uchc885nPxN/8zd+s3HPzzTfjaU97Gi6++GLc4x73wD/7Z/+s6csmDgtddwpd92IcZgMgpZzCNeDYEkIIIYQQMg6ngCNw3nY9UL/pTW/C8573PLztbW/D61//epw5cwZPfOITcfvtty/veeELX4hTp07h937v9/CmN70Jn/rUp/A93/M9y+v7+/t42tOehi9+8Yv4sz/7M/z6r/86XvnKV+Jf/+t/3a5VhBBCCCGEEELIyLhcvl/3utet/P7KV74S97jHPXDTTTfhO77jOzCfz/Grv/qreNWrXoW///f/PgDg137t1/Dwhz8cb3vb2/DYxz4Wf/Inf4L3vve9eMMb3oB73vOe+MZv/Eb89E//NP75P//n+Imf+Anc6U53KmqINVZF/qzFadbEppWmaPLUWZoGxkNNLIr13lyMlBYj5Ilf1GJDS3WXY1fqaeEZ21wclDV+qSSW33KvTKWgpU+LzbfUWFanFTHUo81FzzsLxkr/EcYspeKkY7rl+jbEE5fVKq69JIYzhpZeTkvV40mlopF7x4MWZ9c8xR5874qoSZulxTNrsbMauRhhzd5bpRnUaBGXCeipFtf17gz3flcQM6mtQdo5Qyu3rvSJ1ncELHUypLDy6CrXrrBsTbrCEM97XHJz06qTxw6sKQdjlK4HrVJYWfoypqtnjnne/yDxpBlMrU+l6RSBunfJeNbLg4OD5TriSWlppeot3/P5HABwySWXAABuuukmnDlzBk94whOW9zzsYQ/D/e9/f7z1rW8FALz1rW/F133d1+Ge97zn8p4nPelJ2Nvbw3ve856onC984QvY29tb+RBCCCGEEEIIIZuk6wsfxQ8ODnDVVVfh1ltvxVve8hYAwKte9Sr84A/+IL7whS+s3HvZZZfhiiuuwM/93M/hOc95Dj72sY/hj//4j5fX77jjDtz5znfGa1/7WjzlKU85T9ZP/MRP4Cd/8ifP+/9rAVxcojyAywDcCED+XcvSGUPZUpkeBv1OrFFmWPa0+L8x+ids4+mMjNR41cqUHDY78JQN+6i0fzzycmVj+owtc4xyrWzPI9NT1tLPh0VXSUubTZW1rPWt10tJS5mHdZ5IxtrDjrK9h3j2vxbyWpQ9inOzpp2t9rBSm9W+fx1rvRyzXKpsKzsY65xonZu1cxo4Hmv0mGXXVe4OAFfj3BfI29vb+s19IT/8wz/cP+ABD+g//vGPL//vt3/7t/s73elO59174sSJ/sd+7Mf6vu/7Zz/72f0Tn/jEleu33357D6B/7WtfG5X1+c9/vp/P58vPxz/+8R4LL8Th03Xd8iOvxT4nE/8/mUySH62svDemj0VmWM5StrSdY5Yds9x0Ol35eMq27NdU2dT4hddOLn7Wymm2l7rWup0pXcey2aG+3cXPXl0HfWvsQLbF8jksc1NbAzXb88jT7Nujq7ZeSl1byfTMTY+80G5rxjK2rpXYj6We1jarzY/ZbNbPZrN+t+FY1uib2kNi5XI2usm9Wq6XFvtOzTFtP4nV03puetpZ2rfWPTanq6Ueyzzx9I8ms9U8yY1lK5k5G0rp0MoOLLYm5/yga+ka7TlP1I7n2Gf+Ul21dub6pKW9l87N+XyefS4uSpv1/Oc/H695zWvw5je/Gfe9732X/3/ppZfii1/8Im699Vbc7W53W/7/3/zN3+DSSy9d3nPjjat/HxjeAj7cI7noootw0UUXlahKCCGEEEIIIYSMgiuGuu97PP/5z8d/+2//DW984xvxwAc+cOX6N33TN2FrawvXXXfd8v8+8IEP4Oabb8bjHvc4AMDjHvc4/OVf/iVuueWW5T2vf/3rsb29ja/92q+taQshhBBCCCGEELI2XN9QP+95z8OrXvUqnDx5Ene9613xmc98BgCws7ODL//yL8fOzg6uueYavOhFL8Ill1yC7e1tvOAFL8DjHvc4PPaxjwUAPPGJT8TXfu3X4h/9o3+Ef//v/z0+85nP4P/8P/9PPO95z+O30IQQQgghhBBCjgyuB+pf/MVfBABcfvnlK///a7/2a3jWs54FAHjJS16CyWSCZz7zmfjCF76AJz3pSfgv/+W/LO+dTqd4zWteg+c+97l43OMehzvf+c74gR/4AfzUT/1UVUOsaQ26zCvpS1Nh5F7/r8nsjOlSurFT8RjqlffGrqXSX7VAjm34uv/pdFr1+v0UyXQ7sfRChalncr9H5S8Yyy6GemL1jTG2S3kJmSE1bdbutabtyCFtxpJWSMrzYpm33WIN6pRUE1Yblsg2L2VH5qZnnWuFrDeWwibWP1qqt7Bs7ayz2giw2n+z2eo2rqXuK10v5b4p+yDUR15bptjp+2wfmVJhYVClrMdLUz/KMWi1zpYS9kfXdWq7tDMH4E+bNcwTrZwn5WZp2iyrvuj77DqnrYlauVZ7jzbHtFSiyXqc+sn7tD0sd4627i85uwzx2EFpH+TmkOnZwiCv1drR6uzgoZXu4V6UswNNZrj/edLWjnFudj1QWwR+2Zd9GV7+8pfj5S9/efKeBzzgAXjta1/rEU0IIYQQQgghhBwqqvJQE0IIIYQQQgghFyp8oCaEEEIIIYQQQgooSpt1GLHGD2jxG5JkPEfj2KlobMpS1Jdk5eIyx4jp8sQZhLGEY8VzpGKtYjI9MVxaO3MxlFZycUeleOKywntlOzxxkda4/xyxOFYL2njVxMZ4YvAH3btI+8eI5c/J9GCNZ/TEsaba3CvXUvWmZMh7k9cMYx5bd4f4fU88akq33L0eNH0869oynnnxs7Xf5c+e9xAsdTHMieiak1gvNTvV5knpexJy+0v4DhGJJ77SOiZyLNeB3G+1M4lnXzDF0hpii3P1tro3RLMnyztnYuXkHBtrXdHQbCp3jrbacK5d4fXlnI68/0F7PwZgP2PX4Im796wHITVx7RpDHHK3v1/1fON5N0u4luTO1FpbPHHT1jpL4TfUhBBCCCGEEEJIAXygJoQQQgghhBBCCjg2Lt9jpZBKyahxG9HKavWM5eJdmiZnE+RSMMhUIqX1tro35Za4rn7V+seT/kPrS49rvSR1r9RV6lfqkgusuk3VuEqGLks1eFx2W8m06hO6zuZS4WkhMqVpYGL/X7oOW22mZm7WlC1dr4rSJWXml8STbkteS7mA58iNSdjulCtkrEU1aY9S8lfqM8gM8aRL0vCkT/PsCxqaG3yNy3esTkuqrpowvVZ90HVddH7JeludGT1oKUBbukJroYqhXXrSS2khDrIeq7u6JNcHpfZdk3LPui94bEvqM4yJd8Q95wONGlsL7cuTXm4M+A01IYQQQgghhBBSQNcftq8gDezt7WFnZwfXAri4sI7LANw4Ytnwb0pDB48ts2W5Tchsrav8u17M0GkHtnKe17DVtpNj0r7s0OYTAE7D/pfo0nIhMRuy1HPcx2RT5UrK1thBWHasdqbW+sO6L2jlSudJyTeMrW3Povs6ba9U5qbKpcq2slnPPLFgkpmwy8PSt55yxXNT/H/p/nfY7OAwzM2xzxV3ALgawHw+x/b2tn5zfwSZz+f9ou+KPycT/991XfITlk1dGz6TyWT5Ge6JlYuVTelbWq51H22ynDYm8vp0Ol35bKJ/Qjs4DGNSaj9hO3KfMXRtae8xmzis8yRn79bPMDa7i5/HKJdaN4e1K2Yjh6V/DoMdaHtPrJ0l8rS9SCs3zJfdxc+ltjdWv6bW+ljZ1Hq1KTtoNU9ms9nKp9T2amzWovuYa5e2BlnHoXYdaXHWq7FZTaacJ6XrQa5/wnpSdnkY1+jcflI6N+X4Wfp5zDNtqzNb6bkibFetHcTsWevbUnnz+Tz7bHqkY6i7IN4o/CtYTVxkb/zCXt6XSqEB5GNnrTEAOd1K4zs8dEqM8lK/xmmhUvJXZEZ+1+ygU2IJgdW+bBFnC6ymJpiJOMQx+ipGKCfXlyHrsCdtLGswpTVpbLNa33rijkr1ScnvnXVqaemkHK3ePpNqyVqPvFeLz9sEuTkVTRNXYHuTySRpP9Y55ennTaRo8mBa6xesY45r5NJ2la7R0vZj+5q85o19zO2bmn5hHH4upjT8PbcGWeVLPH3rOVst19oNOX9q7ao5X4bIPUwbv3WsybLNWtqsm266aeXaL//yLy9//qVf+iVVTuk5KJd+0kqrtde6F+fuLT1XyHpz79nQ+r3V2t/i3TqMoSaEEEIIIYQQQgrgAzUhhBBCCCGEEFIAH6gJIYQQQgghhJACjnQMdRhvVBqTUJNDVyvn0adVXIQ7DmqBJ/ZBi7nZ2toCAEzOnsVsNsOZM2fM9VoZK5ZXtmWMOMEw5+PBwcFoMVZaDKUnVjWkZp6sI05aQ5uby1jCRByrpnsYRybRYri09xDkyMUwpnS1XgPK4gVluVzZVN7gGNp6NVZ8Xmk8Va5vU+unZnex6wcHB8mY0lZzah1zc6z45jHqLD1jeNHmn3Vtl9dTc9MSl5yqs+9715wP4/BLcvjW5rqVlLxLoiWt3mEi9wTPOzm0PUzDYz/rmOMSuWY/61nPAgDc77rr8KhHP3rlWi5uOiTM9a7tPTU22+q9LjIvvfWdPSXvIYidn3J7fNhHNfOr9Hw5xnrOb6gJIYQQQgghhJAC+EBNCCGEEEIIIYQUcKRdvkNK0xxJV4NSV791uYNZCVNUTEWKJsmb3/xmvOUtl+Cd77wbHvWoW/HjP/5IkwzZ5sHF+yD4uTVSpif9R8o1pMYFqcRtK+YmlasndAPKUerOo7noeFwPPTJDPKk4LPV4y8UodRnS5ptMQfTQhz4Ut912Be644zG45z3fh0suecvy3re97W1Rmd3+fpluBjey0vR7nnu1/vG4y0mbXYYAZVJ8pa4NMlul4miVmqdUpiyn9WWr8KfUmFhkevbcdaSJDKlJyeQ5H4RtkX2ppfxrRY2LbumYaLYn982xzmjrTnOl7fEeV9+as0zYtzks4U+ajFq0fUHq8zu/8zt4xzvujfe85x54xCNuwbd92+cAAPd6z3vOm1MerCntci7xVtfoGptsFQ6ltfPRj340br31O/CbNz8IX33/v8KHP/yfl9dyczPso1ZhATk3867rkvOrRZjnsXmgJuW85S2X4Md//BGYTHr83u/dB8CVAE5tWi1CLghuu+0KfPKTvwjgLP7u72Z42MP++cpDNSGEEEJsvOMd98Z/+A/fhsnkAK997UOwtfV2POYxf7NptY4dt976Hfjwh/8TPoKzOPjwDMCHcCE/O9Dlm+Cd77wbJpMeBwcdJpMewOWbVomQC4Y77ngMgLM49/fNs5jPH7VhjQghhJCjyXvecw9MJgc4OJhgMjnAu9/9lZtW6Viyt/dNAM7iYHF2udCfHfhATfCoR926fJg+OOgA3LBplQi5YLj44rcDyw1php2dd25YI0IIIeRo8ohH3LJ8mD44mOCRj/zbTat0LNnevgnADJPlFwI3bFahDXPkXb4H3/tS/3fpu19aj5bCouY1+FpaAy1eQMZparqei5m+EgcHl+PchGjvsqHFSHj6J5cqJOyTsVI0hfrm4g7HiMuqiTfR4qCicZuLMZG2Nka6olw6KWs7czFbsTi/VKyTFnenxZ954lE/9alfAvApAJej696ED37wVLZcridyc0hr11ipqDRCfTwpWVLrtcVSwj761V/9VbzznffDyVd/Bs/7vkvx+te/YHnt/e9/f7JcjtLUOLkY3DHSgVhi1Yd3cmjrnKd/PLH0peu57A+ZTiZ830ervVrTVa4NWmyo9TyS0zP1rpjYO1ZMtpVYQ8awvZp7Q3Jnh1LWkRaqVZpB7R00OTzpiayxxhJPLL3Gf/gP347wTPtv/+25PfUkzr3jJ8TzzonS5wOtXbk6Q51M6TgTa5d2NvakWgv51m/9LO53v5/HvU/fGZ86cTuuv77s2aHERkrWy6HeWP1h35buZ0f+gZq04hQu5NgHQjZJ152bf4ft5YYXCu985/3wspc9AVOcxf7LZrjPfa7AXe96/abVIoQQUgTPtOvg/vd/F/73D12HX7j/4zetysbp+nW/2rABe3t72NnZwbUALi6s4zIAN665bEm54Xh9IlJWHr1jA3lU2llaLuyf05l7x+gfKdMymY7imJT8Fd4rMzeWrfo2bMlQZ+sxKZ2blnKpshbWXe6oyNy9+2/ilf/P92EfM0xxFs/YegX+6UX/AgBw2223FctstUbH6kmV0/4kU2rvcm5qczElP7aHtZKZItbOifwWKrKWtd6rY/dJStvZYt8slWmxtVRZL0dpDTos+0kOq81KHQ7bvlkj0yK/+vyUqNdSNqSmf8bYF+533/sCAL76b/8WH/nKr8THP/EJR+kvyfSco1utXal6pfw7AFwNYD6fY3t7W6+8P4LM5/N+0eblp+u65EfeC6A/ufh3MpmsfMJ7ptPpyueVr3xl/7//79f119z9N3vgymi9sc9Q9+7i59T12DWpr/dTWq6FTK1d4fjk+scytrW6eu0nJVOWjfWBpZxmQ5sYy7HsINYHJxc/t9JX69uxZJbanqes1U43ZQelfVszJmFZn75X9kDfT3CmB/res757bK907YrtU+tc23NjUrqHaftvS9uzzpOjuB4M5Waz2cpHs0PPmJTabMruD8tZxjM3U/2RO1+20lUb29z5qVX/xK7VzpN17mGpsltbW8tPjUzNflqdL+XcDG1C2oEmU7P33Jqsnd1LzzI522sps9R+5vN59tmULt8O3vnO++EXfuHvY4qzAP4hgKtAlxJCCDnqnAJwFb4bl2N3pPdIEEIIIeR4wrd8O3jf+y7FZHKAfb4inhBCjhmncA1eDD5ME0IIIcQDH6gdPPzhn8HBwWTxDTVfEU8IIYQQQgghFzLHxuW7V17TH5JLxRGWla9gf/e7/y2+/uuvx8M/eG/83hf/BJPJH2HoQplqxpOaR0uXIvWz0imv0Nf6p0amxPoq/uHnVP94dA+RqSbCunNt1K6HNpQbr6jukZQjslwqzUKbkbHRBWmzpL6lqUsksXkCnOsPbfxSdhBL/6GNZcwOx6BTUo6UotXjSbOioaWoSN074JlvUZn7+5hMJi7dQzme1GXaeulB2mXpvGk13zz7iba2ynmi2VeynojsaKq+hK6afp7+knYRlm21rmmMtcdr6e5yMrR+j82p1Pkp7FvPvPXM1VJq5maoXy6tYLhvtlrrpcyYzQ7nJ+s8XqnHcCaJlesS6dO0M5u258qUdutI4RimzZPr2v3udz/ccccT8Ouf/Xrc4yv+Bz772V9bXpP2bZ1DEk+/SxuNnpcT/2+lJIVdiUwtJbDlzGax91ZrrZVj80C9Lu5+97fiRz71F/j/3XrrplUhhBBCCCGENOaOO56AW275FfwBzuLglhkmk/8HXfeaTatFDil0+SaEEEIIIYSQBZ///GMBnMXB4r1JfX/5hjUihxk+UBNCCCGEEELIgi/7srcBmGGyeG9S192wYY3IYeZIu3yHsZ3WWMjQpz4W46LFflx33XUAgB8BsJ+J5S2NYZCxRMPvk7NnMc3EGVnjNGviCEpjQdcdywDoMS4S2e+WOJY+U6esxxOvK68PsT1dJC5N6lAax5Yao77vRxsvbZ5o45cqF9PSE1M2FuuQo73/oTRG2BMjVRO3FdO9hz/2O2ynh1ax9J6431Zoa5enLdb3Rnjj2sN4Sw9SpsRqb7kxCduylOmMKZV4xiRc26fTqXn85H2t4pCte1+s/tJ3NXh09cTZa33pGU9PLG+4b2rUvN/Ac77zvBtBw/NeIE2fEBmzrPWzFu+dwzrW0n5/8Ae/Ah/60K/jLtft47bHT/F//98nk2XHmG+Smhjz1PtqJLn3r8jrwLm1azadruiTs1nPe4FK49NL51TYV57zL7+hJoQQQgghhJCABz/4ffjnd/9ZPPjB79u0KuSQwwdqQgghhBBCCCGkgCPt8m3+Gj7iLmapQ0sxUJOGQnOpkO4Vw+8HkWtbW1srv4fuFq1cGDU3Mo+Lmcn1IuGO6nHvKXUNKXKN7nvV7V7iSUEkdQ3dYHP9Xup218rlzFOvB2sqjpyuMuxjcVNVmpPcmEgXohYyJaWpSjRapc3KEa6JNalSwrbl5mbp/pEsZ0gLFSJdfcN56xkjzxokse5T4foTS1ViCTOJhchoa3QunWJMPwseu/SMQzie2pikXM5LQhxaodlB7PyUWg+i61zkd88a3crFU9IqVEISps2SMkpTidWE05SmEpSUruda+FHpXJQhDrl6StOD/dzP/RwA4FuCn8+r01BPK2r2Rmtf50Ilw+vyWaY0JDRnl2P0rXSfD9OnFYfsVmlECCGEEEIIIYRcoHT9ut7K05C9vT3s7OzgWgAXG+6P/b3+BIDTsAXESy4DcGNFOamPRYeYzIn4y9FBZChLdR3Knhb/F0pItaO2f0o4CjKH/qq1PW1MtHKHvX+OsszcmHSRa0ehnR6brVkPYn/ZPiz9Y12v170ejN0/HpuN3Vsi01NuDJk1YxKWXeca1OJcofWl5/y0CTsoLWvpr8M6Jlo5jXWd2dZhB97+aSFzXeWOisxh3z7R9zhd6G23qTOt5fkJAO4AcDWA+XyO7e1tvfL+CDKfz3uc6/O+67rzPsO14TOZTJaf6XTaT6fTfhfop9Ppefdqn6H+k457Q32GcoMOw8ciOyZza2tr5aPJLPmcFH03mUyS/Rpe88oM+zU2frExTrVTswNrv9bYgWaLQz/tLn4eY0xatjPVr96+HWNMNDvI6Rqzo5TttRqT8FormaX945Hjsdma9WA2my0/tTabKmux4Vg52a7UWuTVt2Yv0vrHMt8sczO2R6XWA20/k/beaj2w7KFj2rs2njnba7lXD+Vq9gXr2pXrH22ehDI9a3Rt/6TKavO6RmZo69pZL2cHY+zxrc5suXLrWA88/TPGGlS6n9T27VjlrO0MP8Oevbv42duvg8xNnGnl81Ou3Hw+zz6bHukY6pDekOph5X6ciwVolWrCo4+HMIaxE39RCX3+a5D1hrq3SoUj+yN1ra9MV1La71KmVudwbywNjKUve/jjHrUxKe0vGUMiY2eq+3LkuOQUOXmp6zVztjSlVN/3K3FINbFD2nyTWGMdc+lRQpmetUKObRgb5onb1mxfe3eGvLfmvlK78cTOeuZ4eC1XTrs31EnOaYk1NtRjl7l1TpMZ6utBs3fruyt6w70hMpY+vFf2l9Y/Y61fqfNTLJbeuh5o54HY9dS9uTZrdlt6tsmlFdKueXQP9as5E6XqlBSNQWI9sI59zg40fVqNX2lcsqd/NNtrNbZjnbskoe5D3/VYT3x3DOtzhrxeo28KxlATQgghhBBCCCEF8IGaEEIIIYQQQggp4Ni4fJcyVgoNjZIUHxbJpWkWkm4SGfdrj5uydm1wPe729zGbTqtcMTwuVSl9ZD2pe2O1W9IKxVxZS117Y2VNKSuQd3mZTCbV6ZI0l0V5b86NrFUakcOG5gKnYepLcW8sRZNFxmAHmstwDs0dNHYt5VZqchnsz09tqM3xZRhHwdz0uBe3suEuSM1Tsy9Z18tSG/XeX5p6UaKF5Whoqcw8oTYe11pp797wtZh8L7m9PCVD/h72VzKkSKQ8itWjpRm0pGiz6F5KLq3Q8nwQkaeFpIw1tiEpF/0uY3dAeu2q0W2skEvNLX8MV1+JXC9bjZ9HpoYnHa41tKZ2L7KinRM94Rhj6MpvqAkhhBBCCCGEkAL4QE0IIYQQQgghhBTAB2pCCCGEEEIIIaSAIx9D7fWDz8VpWl+F70HGIUpapQMaIw2EFifmiV/S8Lx6Pxdzo/WRFpfliQ2tjRtNpSDS0NKnSbR0N56UOgcHByZdx0g1l4s/k4T9k0OLG/XEdGljUhMTb8UTc+dJ0aQxVoyUNU1O7l5PHFns3pK5uY6x1lK9afGoNSm/oroW7Jva3CxNuxTWG7vX8+4R6xrdao579pYamdq7NDS5qfcvxOrR1kttL8+lJEvZcN/3G3nvjUeG9f0GrXSTcf9aeqnUOSemSas0Yxre1HSpe1Mp7GqpOT9ZSbY58w6jVD2W995IwnbKeautBzVpz0qR60Eo0zPunnhrK/yGmhBCCCGEEEIIKYAP1IQQQgghhBBCSAF8oCaEEEIIIYQQQgo48jHUg/+8NbZhXfk0Q3J5VddBmBNSxkhosRZaHNlYMUBanseaOJ7SmLeaWKLSnJlartLSeO9cuVh8f4v8wxpaHFRJ/lpLibDenO2ldJUyc7FOWjxqkV1UvjvCul564v49fWB9V8WYa+Um8pq3khPGaUo8favZgUaruemJwZOMYRue9TKpj/P9D3INKs3xK/M+l+bb1XJL18RphuRiZcOxlf2T0s0rU9pPaQxlqc22yhte836MsG81GcAIMcIRGR57ssZXA6vvzPFQsx6Y9EFdrmTt/Q+Wfd2CKUd85PdW61EOT1x7uG+2irMP4TfUhBBCCCGEEEJIAV2/jtcgNmZvbw87Ozu4FsDFhXVcBuDGNZfdpMySv4yuq52DZicAnIbtW8ZamZ5y8u/Pg37esp5yKdbZTqD9mGh/y99E/3hsT7OD04lrGofVDlqWC8vG5oK3nLesxlGam1q5sfqnZTlrWc+YWOzpsLYzpHb/i+3xgG2f39Re7VkvpUxruZxMSayuo2A/NeXCvs3t1aX9U3N+inFYZWrlLsQ12roeHfazzB0ArgYwn8+xvb2t39wfQebzeY+F92vs03Vd8jPcc3Lx72QyWflo9cqy1s90Ou2n02m/u/jZU7ZUpiwX6wOp3/AplTnUf3Lx8xhtzI2ntawsl+qDWpnWdlrt0CtzqG938fO67C5le7KdsTlaYj9h2Zo5bVk7Wo+JJiPVlpbt9JRbx3qZG5PUPJVltbFMtbv1GmTpr1i5Gl2t/eMZCzk3LfO4ZL1M2brXdkJ9a2yvtKzsA9lfrdqpzRPNnmazWT+bzfrdxc/r7h/5f4M+w0ezPav9jNW3Nf0TtjE3T3LrV4t9s7R/PDK1dq5zPykpq52ftDOjR946zpc5G5bjqX1azq/WYzKm/czn8+yzKV2+CSGEEEIIIYSQAvhATQghhBBCCCGEFMAHakIIIYQQQgghpIAjnTar67pl4Lv1Vfy5tA9dYVoDKTOkV169n5PZBak4cqkmStFeH+9JUzHo2kVSsmh0SioXibzmSeOh1SvbVZpSR/ZXr6Qq8MjolJQsGp6UbVr/1KRAyNn/QJjCI5aqS5vjqfti93rsS8MzJrE53kfkjaWrVtYj05OqxGPv4bxZXkusB9Z0FzX906redaXjaiFT2kFsjg1reysZ3utWwjEaa9+UhHuRtBFtvqXqAXRda/bNYf3u4VvLpUzPfqLpJ3VInYlq1ssaSuuV54GwnTV2kNJnrPZr+vR9f147w7Zp6/Um1keJ1s9a2shWumtnfs852isndS0nT7te+vwk0dbsVmdaTWZxOsCiUoQQQgghhBBCyAUOH6gJIYQQQgghhJACjrTLd4nbi+bCkSsbknM1Cl1gBpeXlMywrpT7Qtf3VS4mpe4X0l1Hc+nI9a1Ft5yeKXd+r8wcVlc7ieam7JGRq9eKxyVew+MWWIq0gxL3684wJh5K3O5ihHYr3eVKKXVPl25kpW5RsmzKxTtme5pLVy50pFVYTmpMckjdl/U1XH9yrq2Lm6Jutx434bAtcq2PuSkPYQqaHWgujLnxsrrzr9QbkRlSEwLiIdyLNMZwqfS2weNW2kqmh5jLfmwdGVOHFtSEkmlzoVVImme+aXJkPVtbW+Z6S2m1D2ihZLLesF1nzpwxy/RQuzcP80RitRPP+qitIzlbC/Ut1TWnn4cW4Ub8hpoQQgghhBBCCCmAD9SEEEIIIYQQQkgBfKAmhBBCCCGEEEIKONIx1EA+DVXqHsu9qZi7WFoMi14pLDEc3igBGU/h0WeMVD2eMUnFKAK+2IqaWDktVqYmXm9RQdN0CBpajHkuxqXruqWuktL401JdNfmAb554xsSSJqo7OMimFWsVv6TFHY2RsiIXN176vgo5x8P+CseyxrZy6ZKia33E3nM2EcYXe6hNFzjEmHtiv2R8ntcuS+LaW73/IaUTYEvnaNFHG5NW54ocrWJD15Emp3ZsU/Wk+l3a+7piqE2pTSPXW6Vsq4l9blGuRs5hS2VW806OcJ9aVzq+EM3WZDpOy3udzqvX8J4L6zsVcrZW+mwzFi3Gj99QE0IIIYQQQgghBXT9YX9NYoS9vT3s7OzgWgAXR67Lv9fHGngZgBudcod6TxjKhjoM8ktkDnjLhrqeRtlfgUr1rS2nfd+SakdrXSfhN7CJKbLu/mkts2aexOzbWjaHpVxK93WOycocK/hGauw1qFTmOtYuy7dptTJPi/+zrIGHZW7m6PCltV0yRjtz+8kY64GUqbGJNah12dj+d5xsNizrmZvH6SxTOp5jnWlryx7W80HrshyTMpljll1XuTsAXA1gPp9je3tbv7k/gszn8x4Lz4bYZzKZrHxi95xc/Nt13convEdeG+rbVWTHdJAytU9KH0vZmPzdxc+yXu1TKlMrp/WzLCfHLzeWLWTKz9bW1vLjkZnToeu6/uTi/1v1bWm56XS68onpPuiamgveMWnVRmkXYd+ua0zCOTabzVY+pe3M2ay2BmnlPO3U1i7LnLK009JfqbG0yD8ZsRGLTcTs3WpPXnuvtb1hbc/NY61vre3M7SdjrAdSpvxY2uwdT21MrPWU2FDYP1pfavt0q7k5ZrmhbGr9juk+jPHu4mdvG1u007K2htdTZ5lSXS1zvHZMWpbb9PnAU9Y6p+W9nueMMXRNrU+p/SR31is5P9W0s3TfHMt+cnYwn8+zz6ZHPoZ6QIu71eiU+LM+lefaUG+pP77UJ6VD7t5OxB1pcdqt6JT4M60dklaxKKa+S8QhWvMu5/oyaUMiVlPe57GDUqz5WWOyx9DHg9TVk0tSGxMPYYywtJfSeZzTQct1m5r/8ppVBvCluKtufx/T6VSNi/LE+Wn91cq2ataR0nW3VEaJ7fWItzHcC5P1Ot/jkHu/gXVPyfVdzA76xc+lY+Lp22Xc9v4+JpOJGgvaSqak1G7XsSbn3s3itacB2Zfh78MY9KiLAa6Zt9q92rWid75E5qb1XR7eMQlltiTUV4s1brWWeuKZrefmmD7WOV6TE1ragaaPppuUG86dmvjvVnt1q/WqNCe7JGUHrv2jWDohhBBCCCGEEHIBwwdqQgghhBBCCCGkgGPj8u1OS7Nwp/C4CNS6owzuH1oKGYtrj+Ve6SaluTDkUlhYaeXypjGWu6WnntCGcm6ApnpwfjvGcvlu5a5j0j3iuqbZWs4uQ3tPpQDr9veLxzI2dutwS9Jk5NJxhYxhe55UZh53TM2+c27m63ALLC2XCz2Kujs63a9zeNwdtVQq0XKJeSJDjEJKXbWX+2aif0LdW4UJyX3T2j/AeO6zhwktlKwGi3tqSQrQJc49XuKxA43S/dfiVm4JAfHsPa0odZf30Ooc3+pMJNFCHErdyiW55wxNn3DPLQ1j3BRjpCsrPX/zG2pCCCGEEEIIIaQAPlATQgghhBBCCCEF8IGaEEIIIYQQQggp4NjEUFsZfONTcVkaYYxCDplCJpSvpfyJ3Q+gOgbIE99Ryj/+x/8YH//4o/A7p++CK07chhtueNHymieFlSUdwYCMZ2oV66RRo5+VmjGxxue0SiPiSR+jxRJ53m8g6w1jHz0xQGPF/efiwa147EcbE+3eTaDJz6XJCePKU3bglemxWQ9WG265tnvaaYqbBvC85z0PH/3oI/F7fzrDU7/9LP74j5+/cq81zWBNO0vX1qKY7jW+Y0Xy0z/903jf+x6Mj370q/DWt/4MgFPNZZTisdnkGhQpZ4kxtaRPG4sxUnmOlXZNYj1fjsVY72rRYsM97x5JyVvBcDaNjV8qrn2dKe4GtHRl4Z471nil9LM8T5Wi9YF8RtPe0WPlgnugJuPx8Y8/Ctdf/6OY4iz2r58BuB5ddypbjhBCyOHlox99JP7wD//JubX9D2eYTF6HyeQ1m1brWPK+9z0Yr3rV/4quOwCwC+AqhA/VhBBCDh90+SbN+MxnHo6u28c+Zui6fQCXb1olQgghlXziEw9ZWdv7/js3rdKx5aMf/Sp03QH6fgLgLLiPEkLI4eeC+4a6RYoBi0NEWDYsJ1NYAeO8Qr/Gda2U2247hb5/EiY4i4N+hsnkTei6c/1pdcWMtTHsH1mPbKfbDbAyZU2pa9E50el0UimXHG+9Le4bsx7NBW5ra2vl9zNnzoyuT6kbfK5czNUolRbKKt+T7u6DH/wgAOBeP/zD+OArXoGHPexhUd20evpIyqR1uK5JmdY55kl3VRN2Elvrayl14wZW1yTZV57UKmG93/u9d8df/MX03DfU/Qxdd0NRqkrPmMi9WrrotUoBGOLZb8dK33bOzXsX5x6mZwBuWF4rTX/ZOj2RJY1eSr8uoouWuk+2I2ynbLO0d82luWaOldZTihbC45GnubmOhdY/co+X42dJFxbDk17SOk9ajmuogxyTpA1ndKiZmyGeNXrYa7r9fcym05V6c2fWUF9JTerFmIyVew3PCqV7ywX3QE3G4653vR73u9/z8ZjPPAxvv/T9+NSn6BJIyGHhuuvujHd/6Ll45HV33rQq5Ijxrd/6WfzMz7wbH/+/3o37Pf+R+Ff/ii7I43EK59y8L8e5h2n2NSGEHHb4QE2acte7Xo9/+ne/jvfe9f6bVoUQsuC66+6M5z733pjiH2D/uVN03ZV8vwFx8a3f+lk84g9fhvd867/dtCoXAKfAB2lCCDk6dP2mXxtZwN7eHnZ2dnAtgIsL67gMwI2R/w+dB1IdkypbKnPMsuuUede73AUA8HX/7/+Lv/zyL8dtt922vGYxsqPYP6cL3L1iMvV3Mn+p/9bdzk2OyUS+Db+wbz0yS/CWHVp1AsBp2OZGTOZp8X9aPX9yv9/DKz7+D7CPKabYx3fjF3ANXpwtF8o7cnNT/F+rdsq5etjmpuauVmp73/It3wIAuOv73of/+fCH461/9mcr1619WzMmqX63lPUypr2PZT+HvX9C22vWTuP+e1jm5qZlHpa1ayj7jjXu8TVlRx2ThA0fhX1z0P1E3587C4fu8w6Zh21MQu4AcDWA+XyO7e1t/eb+CDKfz3ss3vBu+Uwmk+Wn67q+67r+JNB3XbdybTKZmOo7abhnkNN1natcK5lDe3YX7Q/vm06nK59Smam+OxnRx9PGsJz81PRPq3KhDdXYj6fcMFa7kf4Zq51auTHGRM5Ny73yE5Op2btH5tbW1spHk2mxi1g5zfbr1pIre6DvJzjTA/3i93HnSSvba2Xv4/Rru3Zquh62MfGse9o80dqd03XTa1Bu/7O0MdZO7/53WGzWU1b2nVyjtf6xnF1at1Oz9dgYlcyTVrpaz3c1MuX58jido1uU86wjnvEcs43HcUxSZ0TP2j7cO5/Ps8+mfMs3IYQce87FZX43Xgqm4SGEEEIIaQdjqAkh5ILgFK7BKexuWg1CCCGEkGMEv6EmhBBCCCGEEEIKOJbfUMsg/1Qetb7vR8ujGtbbiRyn2r0eLPn0epzf/mQuZ6c+nhyGHhnatVyOvNL8cR5i/Twg81KH+lnz/XrkA4X5diP1tBqjUrR+lVjnOHC+vYd5HzX7kXpY82Dn9NHI5aTcNKVrRZGMRE7o0jk+1noQ4ukfrZ01/dxqDQzXFc/aJXUffo/lH5Zo+2ZRHxjK/JN/8of44Afvg4c85JP41V99+rnykRzxUr51nZVlk/Ycaadc28N6PWtX6R4R07cFnvVxWBNjY+JpV6reAS0vrae/uq5L5nkf43wi7ceaX7dGB0/O49iZdyG82XlOy8GeKxue2VJn42E8rWeiZc71/X1MJhP1zJ0bg1w+ZyuhTNlfrWSUMtaakzvjpig9vx3LB2pCCCGEEJ0r8Uu/9FRMJge4/vpvwGTy3ZhMXrNppQghhBwx6PJNCCGEkAuQKzCZHODgYILJ5AB9/52bVogQQsgR5Nh8Qx2670j3BeneACDpklOK1cWrlQterq6ly0mknUVuiZHfk+45Bhe9mPtJzKVLkuu/0v4tdR3zuAFK1zWP7Q19Emudp54x3Lhr7Cl2LeVeFf7eyrWvRvfmLnuoc/H2uJFp47AOV3+tL0MX4dg6YnWjrnEnLOpLZwiRti/U9LPmOh7clF2jtTnm6a8w/MiD7J+Sudply12Pg4MXAjiLg4MZgDfi7Nmz6HH+XPS4CHtcKrV2euyidCw99bQKX5P9I38P+z7c+1q6praqK9a3KVfoTYdKjeVm7pFjCn8w1KOdRWXo3XKsI/uCtuda9qkYOZstDeGRxMLXLOcnj+17njtK8dSpPdtY5fSG80EJx+aBmhBCCCHEzrl0csDlAG4A08kRQggpgQ/UhBBCCLlAOQU+SBNCCKmBMdSEEEIIIYQQQkgBx+Ybam9cZI+8H72Mw9BiLVqldpGEsSrSx1+LbdDSGtToY42r88SC5VIwWF91nyvXKsYsREtrAiTiZxL/b6UmlveHfuiH8LGPfQM+/emH4t3vfhnCb2ZK0660iqnxpOLw4Ilf9BDOTU98paZDzdiWpmjaBJa5mLIDLe2ZJ84+7GsZv+9554Q2fkXpkyLXJJPJxBRD5om5NcULFsS1l5KL09T6K7ShViliPG30rF9aTKC2xw/nk25/H7PpdC0p9mpSG5a+A0Oj5T6h0Srd5Bj6BILRdZ1q7zX7VKoPYu019VemHIDoXLCse56zukb4/gfPmid1rVkvtVjxWDtrz0+elKStkDI1G5bng9JnrTHadWweqAkheT72sW/A61//fHTdPoDvwrn4Qbo7EkIIIYQQUkLXb/qrigL29vaws7ODawFcXFjHZQBuBCD/zhd2Ruovj0PZUpklxMpquo8l8zCW26TM05l7DtuY/O5dfwWv/p/Pwj5mmOAsvhsvxTV4cbacxdZa61rCYbGDMfunpuxxGJPQFlP9bJEZ83s5gXNjWbIprnON7tBe1zHLbVJmq7lpXQO9+g71xsbTcj450fc4Xeh1cljsgGeZdjJVm0lcOyzttOh+FNa9lrpa9rtYuRKOgh3UyvSWuwPA1QDm8zm2t7f1m/sjyHw+77Hwwoh9uq7Lfk4u7ptMJiufsJ7ZbLbyGf7/pCI7poOnXKqeWFlN9xqZYVnZb9ZyqT7ItTF2rzaOWjstutf2jxyD6XS68jlsY/Jd3/WyHuj7rjvbA30PXKn211DOYmuWdpaOpad/xiqnrSWWcS/pn1btzM2xsfp1jDEJ+7nGhqRNTyaTfnfx/6VjIu+V9Wu6euZ0SteavtXaWWs/LWzWsnbEZLaam9Y10LtGa7ZnOZ/sdt3K+WTMMfGU88zNdZxlasppY6ntm+vq23CeaPaeutb6TGvpL8t6GbOR2nXPMzdL1z2pa82ZrcW5a6z+GUum5xy9Ll3n83n22fTYuHyH8c5a/ESYC3gymZwXQ9IpOWHDuIgcvSP+rBRZT6fE1XhkhvrW6KqVDXUdfrbknc3lxAuve2Ikon2XkKFdK5Xp6eeaMbnb3d6Mb/3W23HLLY/Ahz70ywjdvbV6tfj9mlgUTaZ8h4EpVtTQNzKODLDlQJc2EureKqdpzdiG7ZL6hPVqcyZ3r4bWPx5y62XYNql7IDybZ1KLVV2tSl9ntf4q7b8aOyidm9Z1LnZfbD0/7x7nOiFlynqta3arWLlWa3Tq3Sw9dBuVhOViZx7Nppd7rmHd02j1bo2SmHNvOa2eXF3R81zkWo0MScmZpM+c2TxjoumeW6Ot/eVZL7V3a5hzJTvPtNoaVKqrJGdPWnltLpTaXq5/tHNGqzOtp17rNXldXgvbVfo+imPzQE0IsXHve9+Ee9/7JnzoQ4ydJoQQQgghpAamzSKEEEIIIYQQQgo4Nt9QW7+iz7lihC4BqRQDMUcGq1tLzl2uxmVQcwPSqEmlECLdgMJ2WdypeoOuSZcOg2t7aT973No87mCtXP8lmhvQ7/3e7y1/1lzKgHN2kUrJUuoC52mzlNnKJTaWYi+1HlhtWCsH2PXNubVq6ZxK561sV84uUnjarN27DK1JhOVoMsLwEc94tXTR09DmptdF1mKzHlq5eErC9d3jhphLk2N1/S1yA4y0s2atD8mdVcYIp0meDVAXrlId1mGoR47JUUq5VRMqVdq3Wr0la2IMz5lWEs7rVmFCUldPylsNT6quUmrOMq3GWsNzzihtS25f0NZoT4rLEHlvaCOlZ01+Q00IIYQQQgghhBTAB2pCCCGEEEIIIaQAPlATQgghhBBCCCEFHJsY6pBWcRme2KKadATh71qsRy6+0pqqQ8oYI62IJ33DoNuQwkOLnU2mZImkVZH9HI5nmD5tOp2qqQqsaQti97ZKZabVqemuxQDl5J89ezaZksWTyqw0JVnNvSV1xuovlbmOdEmlqfBytmeNKV25jnYpmnLxzKG9pWJ5Y7XXpLApRYuB1+6tsfUxYi9z80Qbk3AN8sTr5+wg9i4E+XssVVdNejBrPTW0shFtjV5HekcNT8ykZ0wk4fpVWi4XS++h1ZiEyLNMqxSOkta213L2mNNmOZFrkPX9FDXpm1rpXlqvfKeStmaXnnNk2dKUiDXvnPK8d8MKv6EmhBBCCCGEEEIK4AM1IYQQQgghhBBSwLF0+dbcLcK0KjVutzVIVwOrq09JqqfB1VdzJW/uYuLs20E3i3uxlv7j4OBgxV1Fc30KU6DF7tPczJc6GFLzaG4tpXhcqjWXpZRrpiybI+kStLCDsN4ad7TSdDKtUmjUoNmlJ81Y2LceN7dSl0VPuVbp92rcK7X51srNdaz0aZ7UfX3fF6Ww0tZoTdecW6nFDc8ykq1CJUKZuXU3Wo9hD7OkfhsoTQ82ljuoB4/Namt0aHvSfjSXz9B9f13941mDTOnmCuq1utbKs0xpSrIcHldfbb8L1xJPmJ7GWCmitLW1le2VtjnHWKGuYbu1fcHTPz/2Yz+GD33oYfjYx74aD3jAR/D7v/8DJaqruuZ0aJGu8Fg+UBNCCCGEEEIIObx86EMPw+///j9G1+3j9OlvA/D7AE5tWi03Xb+JP3lWsre3h52dHVwL4GJn2eHvFScAnEbZixEuA3DjGsuVlD2K7WzRP+HfoyxttsiU328M9R4FO/CUi7XzMI2JpZ5YWctfKccek5jutTJPi/9rZe+l5dY1T0rtoEZmadlUn3hljjU3rRzF/cRadtNzs7Zvj/vcPOy2t+m5WVvOWtYzTzQ7kOOpUbpepjiMZ9qjfL5sNTf/+c7/F789/0fYxwxTnMXT8FJcgxc31TVXLmWzdwC4GsB8Psf29rZeeX8Emc/n/aLNpk/XdcvP5P/f3tnH2FXV/f67z5kXW+lMhdLO1JZaEOHBlqrQNg1ay0NTwFrry5MriILGgOjwqIhcglHxJRFTE/NEw9WYm1hvriJyA0xbX67FvvCgFUqFhwJSaW+hIB0ImJ6pFmznnHX/6OzDOmv2/q2Xvc45M9PvJ9nJObP3Wr/fWuu3Xvac9Vu/UkmVSiW1AVClUskrn/QaDEhTJF1I2naUM63jwdHP7aifcrlcv4rIzLKZ9NLL2cr6ydNX19W8zHRZ90ybSa/QNjHLGatNTN1c03Z0dDRczbI96cqqg6J1m2eXLnYQq4y6DL2MRcvpagdSOfPuucj0TZenb1afCpGZ1dZ544iUjzQGSfWVtumG0c8+MqX6cWkjF9uTZEr9whzffcZoyfZc2t1s26y5ukj9uNhhM/umZHu2unRds9nqJ3SuLlq3WX262WNQiEyf+vGxH2nO18cSs+7y5hDfNgltT59506dvuoytzZ43Y6XNmvOz5gVXOxwE1L/9208UoFSSjChAKWBNdF1THULXl5VKxfpuOmm2fCcO/lT6Z4XwkCyxCd27L/ks2kKO6CSBviCS75Atjxj+Clm4+p+YfmsuNpNi1ldWvimZIayqVZRKJVFXnzbxsUvp2WaFT3NtE9Mfx6wD3ffZp36K+Ez//OdH8J//Wca73lXFZZc17oeRfMFMfVzb2sxHCifTirBPPtja2fV8AxuhZ074+LXGGutbkU/o+O0jQxoPfWT6+NlLvsU2mYnmG2rKlMYDcwwKHXN8+mboXG2bl5oxVtjaJGu+y9NXupdVTjX6WaqDdtCsccQ1rW7riee5QD7PuoZzs+Wr+3wHnUfRxPMN8uaMPHt3RbLv3PMEPNszlq7S+va4WmPHlbQtfcYn7cFRn+n/A6VWANiG0O3eRULRxRgjJ80LNSGExGUNLrtsCsplhdtu6wKwBhPRr4cQQgghZPyyERN9fcWwWYQQksmFKJcVqtUEx3czrWi3QoQQQgghZJzBF2pCCMlka/1lulpNcHwrEiGEEEIIIa8xabZ8Sz65+l5+0z/BJNQHyESPfWv6bIXGqJR0zZOfVKvoMOLDjTe/I5vPSDN8pmx+ay6+IEmGLlKb2GJf6+TWQYZPYKy4hbF8MUOx+V5LvsaxdG3MdxOUeh+q1RXI8uvR29PHn1EiN3arZz4mof5nNnmZY2tOWlc79dE1ZCzNItbZFSahY5lru/vag80X2kWfxIgtb8tLv+cT49Q2RrvGdvcZa+t92uPshyyK+IqHtlGRedPV99HH37tZZ3Lotudz5oQP0hjkMyZL/qg23V2x2UusM3p8zshxlWPWgat/s2+76n1MmmOLrPl96rnIeRUh+rjolCdTmjd9dG3FerLd7zaT5oWaEELiM/H9egghhBBCSPPglm9CCCGEEEIIISSASfMLtev2LJ8tCkW2LEn6hIbUMHEJFaQwdst5K8KsmHKkbSS2rURSyIO6LIftcpnbrxy2mfuEyTKf1e3A3Eamb6nyCe3ksxXRZ/tsZh0EhOLwwRaiQce179q2bWVtYSyKWQ6fPiZtFWtGXy3Sb6WtrD4hR1zzMbd4mvr59AWfPqbrZ7aJKVNyyzHJGleKbvUtgutWXx93lVwZDmXyKXfInA/4bccOxSfPWGGzTJy2oHpuaba5zMXaGu36bJG2k2RKfbFZYakkpO27zQon5VO3QdvelQp2CxLzFfRRGelc3EOy+mYRu2gGUggrG6GupSax3DNjrXtCXcJC14X8hZoQQgghhBBCCAmAL9SEEEIIIYQQQkgAfKEmhBBCCCGEEEICmDQ+1DqxfHfyfPeSatW6N1/PJ/XZSqpVlMvlaKEdQv1qYoX4saVz9dct4pel+/aFhirI+ruLD0WWTFe/HqWUl0+nHqrLp71CfWdNJL/kWL4yPr6Eki+9zQ59/Mh1csOIZPiCOY05o20p+R21wy/LJfSbC6nuCmPLIYVEq/tzjY6XZlpX/ybb+QZ6vjY/6VBc/DR9fWfNfKRni4QyCQ2rFWs8iGX70rkWQKOdeJ8xIdzPezaK77MD0tkk9T7m6UNtG/dD288n5Fdo3wxqr4JniBQJw+SK2SZOPvAZ94rYmmu4qyJIZ3LY6jl0vWKu3TPPxAnIVzqjx2yH0PHA571HOqspdL1pO6tC8tuONff45BPjPB3+Qk0IIYQQQgghhASQqHYfTRfA8PAwent7cTuAqYF5LAHwoOWZvN/rFgPYafxNqsQ0nzRdSIVn6Wvql5WvSzl9ZLrID5UZ0iatkBk7bUg63YZaWc40nYuthcjU8/VpS6lvTjTbC/lVp9X23sp+Yo6XJq62l5U2jyJt2e6+GQJlvkboGFREppQuS5/Y8qQ1SbvXFbHTtUNm7HkzVps0bQ7LydclrStFbTa2TBditEkrxoOiaUNsdqLMm0cAXA6gUqmgp6dHflhNQCqVisLoTkLfK0kSlSSJGhz9HJLHYKDsQUOH9Oro6KhfPjLNfPR7pVJJlUoltWH0c9a99GpWOSWZWfIHHfTLK3NRXfU26OjoUOVyOffS00ptkFcHaZtk5dls23PRT693lzZpVT+JZQeS7TWrbmOl08cvqVw+9WM+G6t/FR1r82S2euxytacNBWW6tF+MMrraQahM2/jejDaR7NbUJ1Y5JZl5c0bRcsaqV2l9EEvXWO1ppvOZh6Tx0kdmXhvk6RCjfqRxWV+r+LSlZLOSPN9+4rImamfdxkjnM2/6rBOltNLzqT1sGLUPn/K5ritsbeJbxthtUiSdrYyVSsX6bsot34QQQgghhBBCSAB8oSaEEEIIIYQQQgLgCzUhhBBCCCGEEBLApAmbJR0tn+SEZDGP3gcQfMS/ebS8lKd5xL9P+CRXHaQQRM6hnix1YTsWP0ufLHxCVIS2j6mPmU9oGxTRRwnhLEzS+1khBmwh3FyR8okVUkPKxwyLYdZtyOFdWUjh5cx2yHzW+J7VJuazscYV176RW3cZ5fRpk9CwHUXay8RVh7z2cslHstm8kG1ZMsxy62OmHnbNHPd86quIrSVC+JbQNsudX5TyGqt8+qakayvGLhNpLrTVq/RsjNAuej5Z6wMffUJtpqOjcekpzb+xxiCfUKcStvWTlI9e7rx8ssKruqxX8tpSGq80AYXGaHMtqCOFOYu1dmkHPvUVa51ootteahNq9HPo2sG2rm8FzbKLJEnq80kzZPAXakIIIYQQQgghJAC+UBNCCCGEEEIIIQHwhZoQQgghhBBCCAlg0vhQS76Oun+A6Tvk6p9g5mPi4yNh+iSE+mlJ/kw2f1SffPOw+Va45tMsX0tJTrPwsT0fv7r0vsqQEcu/RPJjk/xRbfJ9fdNc/Pry/MKy/JnHPCP4q0ty88qR9ddQP9Zm+VqZfczVt1CyWTNf23gp+fLpMm1jV8i4koU07vr4lKXlVg4y88bMIr6psWzGpsPoQ9ZzLqT6KjJWNcu/Uup/Pvbtis13z3U8SP1xk2oVHeWy1zkgUh8zy6nra8oIGueUGpOPWSdZdunSvyTGg3+uXu68fqIwdpyw+7Wuwf/EhQC2AtjYcEdvz7y1Z+JQr9J4KZ0ZIDEe2kRCOt9nPPh/+8wLruNKkXL49M/Ozk4AQGlkBKa1+OggnQOSN68rpcT3sOCxPSgVIYQQQgghpI2sAbABv8S/A9gw+p0Q0mr4Qk0IIYQQQsiE40IAI6ihA8AIgBXtVYeQE5RJs+Vbx2Ubd5Kzdc11q4oPtrAPoaF5TPK2SRUJ8yDR1dXV8P3o0aO5cny2KUvbm2KFiIkVlkbaqmaT6bN9SN96VCTsio7PlqUiurturfUhT9es3CT9UltLw+j5hIgoGp4oJAxMXp42fLZ4hW71zQsRlYaBca1bc5u5tFW8iCtL5jbXjHLGcm2x4eP6UyqVcu0n1IXIJNfFwRL+Knf7Z4FtpWq0XVz0M/EJn2bagR7m6NixY2I+rmNikTVG1vbrNEyOz7wpudfECtUl6WPec50XbG4kPrqmW05TzPbNI9ZWX59wZdKW6nvuuR5r1wLlpIqq6gCw3dklS7cDH33NflIkHJ6O1L6hrhExcQ0hFyW8a5u2mfusL7VE3uNz2t9qsNuf65zmUx+uY7RPW/IXakIIIYQQQiYY73sfMDgIfHb+RgwOAkmy0Z6IEBKdRLXqXzsRGR4eRm9vL24HMNUzbfp/h8UAdsLtP3MmSwA82CKZelofmSm+uvqkLZn/9R41pax05v+0suogTefybF5aX4rWz07jb6G6upY5Zjl92kQiL5+s9mxmW+allco50caDUJntSFe0nBNxPCgi06efJMivV5d8YuoqyfGVmaV7K8cDM50+x9Ucl0q2eaHIeCnVz3jrJ1I5x8O8mbd+iSGzlePI+9aM+kw/+CCwZAk2bPR/oT6Rx4PxmC4v7XizvVbJjGkHvjZ7BMDlACqVCnp6euTM1QSkUqmo0fJ7X6VSSZVKJbVh9LN5P0mS3Ct9ZjCyTEm+njakvFm65pXLJa1+dXV1NVxmuqxypJckr1wuN1wuuru0SYx0ZlqzXKH2Y6ufNI+Y5fRpExf7NvPJak8X2/PtX7a0UjlTvTaMfo4lU2qTIuOBLlOytVj9RLc7aazIuorWbaqr1MeKtElWmUPKWdRus8ppSyPZj0s+MXV1tWHfscSU6TpvmfrmzalZupt20NnZWb/yyuUyL+SVMaucUr26jrMx581Q+8nTZzDjXui84GqHWWn1ts1q3yIyi64rzPtS2jpr1iillNM8EKKv1E+k9rSllZ51HQ9i2q2rrrHmW5vMWLYXyw6k9UGz2iSmHbjMYVl5VioV67vppPGhTgS/JOUYush8Nha2cECJsF8//a4glzErrY7us+TjJyrVjy1Mhy7TJ6RHkH6ePp42v3bX+grx2ciSGRomAMi3GUmHLJmhfcGmu+TLJ9VzqD5mOqlt9Tyz8o/lj5pk+LRljQc+ZfYZqyR/ZlNmVviIvDMnJKQwMCZSPTfLxzyv7X3nAL1fF8GnnLVaLXc+aUX4Fslm8mw6KzSPrY10Qudm23iQN/8qpUS/2tC+aWufUB/BoDnEs1/7pJP6vE+YJXPezFrPuWD6TLr6TI8HzPo55ZRTcp812yTWGRR56VTGuS6u+Zq6mXYREsYyJj7zgt5Gtn7i+r5ipmtVSKuQfJrZHlLe0vuTtJ5qxjxJH2pCCCGEEEIIISQAvlATQgghhBBCCCEBTJot3zrSz/761seOcnnMVuTQLZ6uWziK4LPlJHQbcMOzlhBNtvrR61baduRTz7Ztdq7bP2zb8KUQHz5b0nWkcEC29iqyJTVLB6B5IchibQv0sdm67FrNWg7JBaRZuOYda6zI20qXtf3alJm1HVxhbP+y6RvqjhELm66hbjAmUugZpy3NAdvpJRmh+eghogDZTUeqr7xwJFla+WyF9EHfJmzre7oOaR3krQ90fOp90aJF9c+7d+9uuOcTDih0jo/V98x5KDRcUu69DDmSm56PfJ8wVT7rHh8dfNaXug5m/bz00ktj7g0CWJvRf1xClCYZ/dmnXKE2ZBt3XdukSDgpVxk2pPaSns3Vp+C8IBFrzjDdMXRirqdC30NiuDT4wF+oCSGEEEIIIYSQAPhCTQghhBBCCCGEBMAXakIIIYQQQgghJIBJ40Pt6iNU32+vlDXkiORnYPNB0P0J6mFDckI06b5rRUI5ZOqX4fcopWvQN6Lvhov/S1ZYDDNtEd8Pn7BZuhzTz0dPG0sfW6gLV78s81nJH8ema7lczgyzlN5LMf0MJRlO/WRUpllml5AHLrXvWj+SHJPccwhyvsdAsr1mnNuQ5UOtY6sDnWaFK9Tb0+brmBk6LMBvTQqb5VMHOj7nNsSqO5/QhhKxzngoguS3baK3Q1oHCvb68PHprFQqhm5rAFwIYCtKpV8e1yNjLoo1DxRB8jENChuZYctSX5DWMjHH1Wb4W8by7fUpt49M/WwNk1aE3zMJbV+f9ZN0VkTQGSEWfZRSXuO5vv5u1tkaufXj0Meks4j0chapS5+zI0JDL5rpssrlC3+hJoQQQghpCWsAbADw7wA2QKk1bdaHEEJIUfhCTQghhBDSEi4EMILjGwRHoNS726wPIYSQovCFmhBCCCGkJWxF+jINdCBJtrdZH0IIIUWZND7UrtR9B0ZjKPrEZ9R95Wx+DVl78PNi3br6roX61WXFi8x7Vv+uAOzatavh3nnnneekq02GT0xoCZsvdDNk6mmbFRs816fbIYZnngwfXYHj9pUVtxiI52+Z10+KxAX2oRnxvYHweLqSX0+WnDya4bPtK9PHl14ixBcr6/yHVvgE+ugq1U8R+48VV9VVhkk7bM9E8ms3kfSVYpW7xE5Oefrpp7V0z0CptQBWANgGYCOUyp5PfGy2WfUe6ywEyV+31fFii+BzVoRP+1155ZUAgLlbtuDKf/1XnH/++fV7n/3sZ53zkc6OyD0vx+E8mNC1jISPTO0hq2+xVO/S2qVZ85LUJua90LWp7RwQXabPmRwuZ33knbXjiq3efd7TJJIkya2fGGPJCfdCTQghhBDSLpJkI4CN7VaDEEJIJBI1Hv6d7Mnw8DB6e3txO4CpnmnT/7YsVgo7PU/QS/9PsxjAg55yAWBJYLo07U7jby6apzL1/zG5lngJgNctX97wt/vuu89Zpi8h6fQ22Qn3shWRWTRtbJnm/w+z6mC86EqZfuny2rbV5Ryv9WPSjjG6XfPCRGmTdsiM1Sah8ybtwC9tM+ewImlbqevcOXMAAKe/9BL+34wZ6J0+vX7vscces6bPkynZcLvXtBNZZhE7cBlXYtdPM2QWXX+HyGx1uiMALsfxSA09PT3yw2oCUqlUFEZ3SKVXqVSqX+Y9/UqSRCVJogZHP0vPSml90qXXoJFPevmk1a9yudxwZd3bMPo5r66k+hocTVsqrVVJ8h+qVFobrKuLTJd6zas73zaR6se1nl3K6ZrOZhOxbE+6stooL535rH4V6WOuMjs6Ohoun/rxsR+XfurbJmb9+Fy6TN+0eW3iMh7Frh9Jx7SNN4y2eai9u45zgN944NOekg372E9WvqF9Wk/rWj9mm5iX3hd97EBqI1s/cbUDnzoqYge6TGlu9pnDfPpm3jhcdOzyqR/XOcxWrne+853qX/7lJjV79h0KWBNkP2Y5i9iPJCOrP6T9xEdmnTVrlFJKDQ0N1S8pXWdnp+rs7FQbk0R1dnZ62YE0b8ZasxWxPX1ckeYF13q2zZtFdA1dl5o6hI5BtnkztG+GjkEx7UBK5zrf2ta0tqtSqVjfTbnlm4go9V7Uavfg+GmknwPwPnCrGiGEEEKawcsvX4A///nbOH5w238D1x2EkPEOT/kmIko1hvg4fpAKIYQQQkh8KpV3gOsOQshEgi/URCRJtkIP8XH8VFJCCCGEkPj09v4JXHcQQiYSk2bLd0g4GeV5Hpvv8yk+oZ18kI6o10NUVKtVrzA+iXb8fq02iOPbrVYgDfHhihQaoFlI5dTbz1Y/+rM+uoeW02ZbobYnIYVSA+QQAzpSmWPqrcvxqefOzs6G73rYDDPsg6mvUxg2hzK62qVzPkoVCjVjhuDL0ydmv5VCEGXJVznypXGlcexy190cD3zwmVNcdTL7Zmg7SPWTJEm0MIOx9NMx69Un9KM+59rCTer5pmODix1Ic4ZPWBoTXV/zWf27T1sWwSe0YaZ+GfdMxj47iDe+cRhHjizBoUP3IEl+iaQG7/WTT6hTCd/5L6+fZOmWktbBIIC1Huu1Y8eOHddj9HNevsDYcqT32hVm0DbOZYW4cqlbH0JtVsrHXPNL/djnnoRtjNbHFbNepTpoxfrXRLILc9wLXZuaSP3ElUnzQk2aCUN8EEIIIaQ1TJu2FdOmbUWl8pd2q0IIIVa45ZsQQgghhBBCCAmAL9SEEEIIIYQQQkgAE3rLd5Ik9X3vRXyjYyD5adl8Gzo6XmuGLJ+RlCCfpFE/Ax8f6lg+Jc3wwTHlmz6wer07+RI5+GEE+bga+gGaTTjIzM03om1Lvju2v8fqY6F+9j4+pqavn95GNt9ZV78an34i+Yba6kD3eZNk2upHL2sxX0d3O/D1TU6x+cDqSD6Bec8C8ey5SP3oNMt/0WeeLHpmiEniWaYiPsK6H77N7qQ5N1MfQ0ZRTH9LF/s25Wf5mEv1Zcp0TeeDz5xq6vDkk0/m3tPJPSPAuJ+liZmv1DdCz8CQ0rXS5z0PvZ/YCJmndBkhuPh/+8qQ+nGsPq3Xq7KcdyLZbK1Wi1aXruOczfZddbClk9a0oWdruK5pbfmGwl+oCSGEEEIIIYSQAPhCTQghhBBCCCGEBDCht3zbtlJkYdsK7Romp8jR8iahWyFdt66Y9SSFzDGR6tcnHIlPvUp1a96Twl+5hoSx3Ze2mZuYz+Zts2mmW4LrFiHbtrskSTK30tvylZC2F5rb9832k8I5+Wwf0utH6tOmTOleno3k6eB6T6JIqLdmhLTL7VMZLg6SHdi2wEq6S1s8x6rlZsPS1lBA22ZeMDRPM7agNwsf26u7ZTVRZohbQFY+EmeddVbD94GBAeze/Sb85S9z8Ja3PIcf/WiNUz55tu+yxVO/l7qKlUZG0NnREbyOyJKjo9dtvW0D3JZ0fNZPNpc5V4psbW9WOEyJWOOBFK6wFS58Ur3b8pTCxI03lx3JHUNC2gpt62OZc25Ousx1zyh6O8Te9h56X0ea833qulQqRQ9frDOhX6gJIYQQQlrN7t1vwo9+9F6USjVs2/Y2AGvA8JKEEHJikqjx/q/wDIaHh9Hb24vbAUwNzGMJgAcBmP/fcamMNG2ozBBiynQts01mXj5ZdetTr+O9TVL9FrdQZtG0Lumyfl9cDGAnwn5d8rU9vV5jymxmury0LjZc1PZ2OsjIkxnaN0OIbQcuurdyvGzXeDBex5F2yLTNRTFknnTSSQ3f/3f3/8D/evlyVNGBMkawGt/DJ3FD4XlTQk+b/sp0vlJ4KOMXKalf+4y1Wf1tvNqBlLbIeBkib7zUT6vHS0m+rkNRmb5zWJr2RLUDnVaMlzHTxhqDEvivL48AuBxApVJBT0+P/LCagFQqFTVaH95XkiQqSRI1OPq5VCo1XD5ppSsr/aAl37x0adpYMsvlcsMlyZTqIy+fNF1ovUptklfmwYz7PjJ92iQt74ZAG7TVq01f12ez6ke6zHpPyyjZiG85pbbV67VcLjvZd9H6sfXp0HKafSO0TfLqb4OlLm26hqaT6idvXMrqY5LuZhklG/Jpk1g2a5ZP17eIzBh2V6ScsezAvHz6Zl46W9+0zUWSnbrWz9lnn91wXXPNRgUoVSpVFaAUsMapbvNs38UO9HSdnZ2qs7NTbUwS1dnZ6TUemH3MZb7Tx7G8edPVhmKNs65tOyjUezP7SZG0seonxlrPN13W+Jhn766XtE700bfI+tLV9orUq08fc51vm9UmRdO5pg0dL7PyyVtX2K5KpWJ9N500W75dfQKV4FtsQ/fxtKXr7Oysfz527FjDvSQw/JX5nJmPax0U8bWS8pFCWEmYbWKWSyIx/E10XMNi2NrSzFfy05R0TzRfS19/rrpfqUOd+ti0lK5Wq0Ehnr2keero9WALYSXh1Icyvtt8h0J9jc28QtskL19VMM9m+ATaxidX+Ynh6xUrrI9kB3XdM/zPXP38irawLtM2RyRJkjnmZT3rio9fuyQzN2yWp162MTpr7PDN1wc9lNPx72sArEGttgLANrhu9zblm3Ur6Zflf1rD2DWGjVC/ZJ9500Sfq3PvWWQCje1uppPsoFnhwUz0vhlr3LfKA3JlSqFE9XEvig4Z+NSBaz7m2t22ZnTVIXcOy6hbn3W8hJSPZPvSs1m6FOm7IcSqH8D9nc4mM13T1poULtDrlO9bb70VixcvxrRp0zBz5ky8//3vx549exqeWbFiRf3AgPS69tprG545cOAAVq9ejalTp2LmzJm48cYbnWOkEUIIIYS0n40AbgB9pwkh5MTG6xfq7du3Y2BgAIsXL8bIyAi+9KUvYdWqVXjiiSfw+te/vv7c1VdfjW984xv171OnvubpXK1WsXr1avT19eEPf/gDDh48iCuvvBKdnZ341re+FaFIhBBCCCGEEEJI8/F6of7Nb37T8H39+vWYOXMmdu3aheXLl9f/PnXqVPT19WXm8dvf/hZPPPEE7r33XsyaNQtve9vb8M1vfhM33XQTvva1r6GrqyugGO4/15vbq3x+5k9/RXfZuKBvwbKFA3IlDZNh6pPSjK1+Pts2YoW3kGTkbiesVse0Z7O2dElbTMzwLXob6VtDa7VaQ3vadJW2mdvswhVpW2mztghJ20qlOsm1AyPsDGDfNuWqnw9SurS9kmoVHeWy2F4+7g/S9nTbtsAQGVlydEK3mPls/fcZn0LcewA5TEdM9H5s68OlUilzzDMJGb+ley5je56MorUWcwthDHL7pme4GHNekPCxEZ0idaf3Qds4Ehrexmdc8RmTdX1d+tQY/TLcKnxcW4rMzZkuKcJziUO4pCJjhVQ/oe49NkK3asd6thX52MisdwcdmuUq5SqzHSHufNrEdX3p4xrsteXbpFKpAABOPvnkhr//9Kc/xYwZM7BgwQLcfPPNOHLkSP3ejh07sHDhQsyaNav+t4svvhjDw8N4/PHHM+X885//xPDwcMNFCCGEEEIIIYS0k+BDyWq1Gj7/+c/jggsuwIIFC+p//8hHPoJ58+Zh9uzZePTRR3HTTTdhz549uOuuuwAAQ0NDDS/TAOrfh4aGMmXdeuut+PrXvx6qKiGEEEIIIYQQEp3gF+qBgQE89thjuP/++xv+fs0119Q/L1y4EP39/bjooouwb98+nHHGGUGybr75ZnzhC1+ofx8eHsbcuXPDFCeEEEIIIYQQQiIQ9EJ93XXXYdOmTbjvvvswZ84c8dmlS5cCAPbu3YszzjgDfX19ePDBxnDcL7zwAgDk+l13d3eju7s7RNUxxAo7Y2L6Gehhs4qEHdJ1NPOJ5VPm6gdpyiwiX/IPknx38uoyy98y1PcDCPfZkHykTB9hH38qSXcnH1yHsA95Mov2E6mts/y7Qvw0fUIXxQoDprenDb2c+lkMIyMjDfdMO5R09fGnkkLThfoWA44+eZ5+2z6+9D66S77zUqiZVuEzHlSr1Vwf89C29cEn1IvPOQASscoSa96MNd/5jNHjPRqK67xZpA18fEpDfSpjnM2glCoUxst3DZK3pnUdD2x1ladPlo+pS/hQX//0IuG3XM/zCE1XRB8bkl3q2EIbhiLpGhoq10bQOQmIN0eE+n971bpSCtdddx3uvvtubNmyBfPnz7emeeSRRwAA/f39AIBly5Zh9+7dePHFF+vPbN68GT09PTjnnHN81CGEEEIIIYQQQtqG1y/UAwMD+NnPfobBwUFMmzat7vPc29uLKVOmYN++ffjZz36G97znPTjllFPw6KOP4vrrr8fy5ctx7rnnAgBWrVqFc845Bx/72Mewbt06DA0N4ctf/jIGBgai/QpNCCGEEEIIIYQ0G69fqH/wgx+gUqlgxYoV6O/vr1933HEHAKCrqwv33nsvVq1ahbPPPhs33HADPvShD2Hjxo31PMrlMjZt2oRyuYxly5bhox/9KK688sqGuNWEEEIIIYQQQsh4x+sXatv+9Llz52L79u3WfObNm4df/epXPqILkeX3mxezTyfXXzAjjZnP0aNHxz6DYj5vzfIh85Hj6lNi89MM9SHx8XU2Y0Dqz5rtYOajp43lX2n6CPvE7NN9VUxc/X6UUmJ8XR98/FaaYdOx8rT5+brYcNFeqedraxNd32YhlfnYsWNRZEg+XmY/Mcdhqf/pMb7NOnJt23b5yoXG8IwVb9SnnpsV/1SKdduKuK+S/34rzuQwMWVKMYWbFac7zy7NOd6UKcXpLuJzK7VJM/zjfc+cSJLEaT7xOVtAetY2drnUl8s5IDq2cy5ixY/W7/v468ZaV/icA+Kz3vW2J4d75udWnAOSysh6tykSg11C8sG3US6Xc+0n72wGrzncSxtCCCGEEEIIIYQAABLVin/7RmZ4eBi9vb24HcBUz7Tp/zMWA9gJ+dcl838f6bNLADwIf0LTnSgyXdL5tElJ+uXWIrPhP1/mfxs99M0iTadrZ+uEut22SqaeLoQTwWZPFJmxdZX+r2z2r7w+n0Xabxcr5TWWFO3TRdIW7Zs+9WOm1XHJJ/YYLaVtR5v4rA8kmTuNv8Vqk6w8m10/7W6TounaIbPZ/SRUZp4OvuuKWP1kvMtsV7qQtOOtflx3i7Ta3vPqJ2/+PQLgcgCVSgU9PT2yADUBqVQqarTM9StJkvrlcm/QeMYlHymtni4v7WDOs6VSqX5JMvXnpGezZJbL5frlms+gY7lc6ke6Ur02jH52eTa9QmWm5ckqo+1qdf3Y0pp1Itl7qP241KVLH+vo6Gi4fPqma3u66udSTtd+Eqstm522mX3THFfSa8PoPenZrHtZ6Wxtq6f1sQNzPIhle7HaJKu+Quaw0HL6pPMZD/JsJst+XMbkkDaJOV6G9LEitqfL85mLfGTqdWCOB7HmP5d5N7R+QtqkyBgkyXNdVxSxWalN8sZd3zEotF5N2yvSJr52l+orjTXNapPQ+smbp0LWMq71E0vXZskMbROfvpl1v1KpWN9NueWbEEIIIYQQQggJgC/UhBBCCCGEEEJIAHyhJoQQQgghhBBCAvAKmzWeUZHC6Lg+mwSE0EiMUElZeUn5+oTeMEMMmOEuXHEpV55+Zlny8jXD5Jjo+fiEAvBpI586iZEOaAxT41Mun/A2JpIN+dRXyHPA2NAJeaEKfPFpWyk8UWioh9C68yXRQka0AjMshtTn82wrq19LdugzHph9IW0vhbFtIo1H9TF6tIw+fUpv62bZgc/YL80n0jwg6W5+lsYgKR9JH/N+mi61g9C6lUK05eqXEaLJh1hhs5pFXtsC9jYCXhsPJIr0hbxni/QnU5+8sQOQx6DOzs7cdDaZscaDrH7igvRsq+ewxDN/KeyoiaR7q8KF5qWzpZX6plP75YT4Cg3LmCvHoquUzuX5PMz3qcL1VVCfBt0K50AIIYQQQgghhJyA8IWaEEIIIYQQQggJYMJv+a5vH9F+vnfaejy6LULa3uS6Ba4oPtsLXTG3x4TqK22TtG0bCdkyrJQSt8vF2sZta0t966+5pUvfTu+zjcxHPwkfe7nzzjuxc2c/Nq5/Bv/94/Owbt076/fG+7bEdmyfdd3iDTRusfLRzWfLkonrFiaXbZt5SK4IQVuPc7aghabTv0t9wacuza3toTR9q3+GHJ+2lurWR3epjkz5ur1L2xBNfLbvSfjkU9fVwWaLjU9rAFwIYCt++MP3AgAW3XYbfjgwgE996lNOOZht6UM6vyXVKjrK5Yb2jGXDRbbESuu5WPr4jPU6x44da/ieacNNth+pTmKsiWyEju1A49q0yBqkWetxV5nSPbN+zHK6usj4YLotmfm41q1tLNHzNdcyugxnl9CCW/99x76UZtjMhH+hJoTks3NnP9atuwBlLEV1XQeOL+Q2tlstQgg5QVkDYAOAEQDX47/+6/9i0aJn2qwTIYSQInDLNyGTmMcfn4lSqYYqOlAq1QCsaLdKhBByAnMhjr9MdwAYwZ49/W3WhxBCSFEm5C/Uvls9sp454pA27/4Rq8TsfFxk5tEumSFpfXU104VsSyoq01WOfi+rflzqy6WctrSuvPnN+1GrzUIJI6jVOgBsrt/z0TUEl7R5fTPvXgyZsdLpdhCaTnluF0/JkhmrPaU28SF0DPJJ5zMejAd7D00Xq58UnRdi95NmtUm7bU9O+1sAn0T6Uj1//l688sorOFyt4pVXXmmKrrlpR8cf3/Sx+8lk6ptKqZauL4umc02bte5u5/pyPK8PfOb4Zr1nhNZPrPHS1f6b+b4gpfPFRU6iWuV8EJHnnnsOc+fObbcahBBCCCGEEEImKc8++yzmzJkjPjMhX6hrtRqef/55KKVw2mmn4dlnn0VPT0+71SKkEMPDw5g7dy7tmUwaaNNkMkF7JpMN2jSZTMS2Z6UUDh8+jNmzZ4uHaAITdMt3qVTCnDlzMDw8DADo6enhQEAmDbRnMtmgTZPJBO2ZTDZo02QyEdOee3t7nZ7joWSEEEIIIYQQQkgAfKEmhBBCCCGEEEICmNAv1N3d3bjlllvQ3d3dblUIKQztmUw2aNNkMkF7JpMN2jSZTLTTnifkoWSEEEIIIYQQQki7mdC/UBNCCCGEEEIIIe2CL9SEEEIIIYQQQkgAfKEmhBBCCCGEEEIC4As1IYQQQgghhBASwIR9ob7tttvwpje9Ca973euwdOlSPPjgg+1WiRAnvva1ryFJkobr7LPPrt9/9dVXMTAwgFNOOQUnnXQSPvShD+GFF15oo8aEvMZ9992HNWvWYPbs2UiSBPfcc0/DfaUUvvrVr6K/vx9TpkzBypUr8dRTTzU887e//Q1XXHEFenp6MH36dHzyk5/E3//+9xaWgpDXsNn0xz/+8TFj9iWXXNLwDG2ajBduvfVWLF68GNOmTcPMmTPx/ve/H3v27Gl4xmWdceDAAaxevRpTp07FzJkzceONN2JkZKSVRSHEyZ5XrFgxZoy+9tprG55ptj1PyBfqO+64A1/4whdwyy234E9/+hMWLVqEiy++GC+++GK7VSPEibe+9a04ePBg/br//vvr966//nps3LgRd955J7Zv347nn38eH/zgB9uoLSGv8Y9//AOLFi3Cbbfdlnl/3bp1+N73vocf/vCHeOCBB/D6178eF198MV599dX6M1dccQUef/xxbN68GZs2bcJ9992Ha665plVFIKQBm00DwCWXXNIwZt9+++0N92nTZLywfft2DAwM4I9//CM2b96MY8eOYdWqVfjHP/5Rf8a2zqhWq1i9ejWOHj2KP/zhD/jJT36C9evX46tf/Wo7ikROYFzsGQCuvvrqhjF63bp19XstsWc1AVmyZIkaGBiof69Wq2r27Nnq1ltvbaNWhLhxyy23qEWLFmXeO3TokOrs7FR33nln/W9//vOfFQC1Y8eOFmlIiBsA1N13313/XqvVVF9fn/rOd75T/9uhQ4dUd3e3uv3225VSSj3xxBMKgNq5c2f9mV//+tcqSRL117/+tWW6E5KFadNKKXXVVVeptWvX5qahTZPxzIsvvqgAqO3btyul3NYZv/rVr1SpVFJDQ0P1Z37wgx+onp4e9c9//rO1BSBEw7RnpZR697vfrT73uc/lpmmFPU+4X6iPHj2KXbt2YeXKlfW/lUolrFy5Ejt27GijZoS489RTT2H27Nk4/fTTccUVV+DAgQMAgF27duHYsWMN9n322WfjtNNOo32Tcc/+/fsxNDTUYL+9vb1YunRp3X537NiB6dOn4/zzz68/s3LlSpRKJTzwwAMt15kQF7Zt24aZM2firLPOwqc//Wm8/PLL9Xu0aTKeqVQqAICTTz4ZgNs6Y8eOHVi4cCFmzZpVf+biiy/G8PAwHn/88RZqT0gjpj2n/PSnP8WMGTOwYMEC3HzzzThy5Ej9XivsuSNKLi3kpZdeQrVabagUAJg1axaefPLJNmlFiDtLly7F+vXrcdZZZ+HgwYP4+te/jne961147LHHMDQ0hK6uLkyfPr0hzaxZszA0NNQehQlxJLXRrPE5vTc0NISZM2c23O/o6MDJJ59MGyfjkksuuQQf/OAHMX/+fOzbtw9f+tKXcOmll2LHjh0ol8u0aTJuqdVq+PznP48LLrgACxYsAACndcbQ0FDmOJ7eI6QdZNkzAHzkIx/BvHnzMHv2bDz66KO46aabsGfPHtx1110AWmPPE+6FmpCJzqWXXlr/fO6552Lp0qWYN28efvGLX2DKlClt1IwQQojJZZddVv+8cOFCnHvuuTjjjDOwbds2XHTRRW3UjBCZgYEBPPbYYw3ntBAyUcmzZ/28ioULF6K/vx8XXXQR9u3bhzPOOKMluk24Ld8zZsxAuVwecxrhCy+8gL6+vjZpRUg406dPx1ve8hbs3bsXfX19OHr0KA4dOtTwDO2bTARSG5XG576+vjEHSI6MjOBvf/sbbZxMCE4//XTMmDEDe/fuBUCbJuOT6667Dps2bcLWrVsxZ86c+t9d1hl9fX2Z43h6j5BWk2fPWSxduhQAGsboZtvzhHuh7urqwnnnnYff/e539b/VajX87ne/w7Jly9qoGSFh/P3vf8e+ffvQ39+P8847D52dnQ32vWfPHhw4cID2TcY98+fPR19fX4P9Dg8P44EHHqjb77Jly3Do0CHs2rWr/syWLVtQq9XqkyAh45nnnnsOL7/8Mvr7+wHQpsn4QimF6667DnfffTe2bNmC+fPnN9x3WWcsW7YMu3fvbvhH0ebNm9HT04NzzjmnNQUhBHZ7zuKRRx4BgIYxuun2HOVosxbz85//XHV3d6v169erJ554Ql1zzTVq+vTpDae3ETJeueGGG9S2bdvU/v371e9//3u1cuVKNWPGDPXiiy8qpZS69tpr1Wmnnaa2bNmiHnroIbVs2TK1bNmyNmtNyHEOHz6sHn74YfXwww8rAOq73/2uevjhh9UzzzyjlFLq29/+tpo+fboaHBxUjz76qFq7dq2aP3++euWVV+p5XHLJJertb3+7euCBB9T999+vzjzzTHX55Ze3q0jkBEey6cOHD6svfvGLaseOHWr//v3q3nvvVe94xzvUmWeeqV599dV6HrRpMl749Kc/rXp7e9W2bdvUwYMH69eRI0fqz9jWGSMjI2rBggVq1apV6pFHHlG/+c1v1KmnnqpuvvnmdhSJnMDY7Hnv3r3qG9/4hnrooYfU/v371eDgoDr99NPV8uXL63m0wp4n5Au1Ukp9//vfV6eddprq6upSS5YsUX/84x/brRIhTnz4wx9W/f39qqurS73xjW9UH/7wh9XevXvr91955RX1mc98Rr3hDW9QU6dOVR/4wAfUwYMH26gxIa+xdetWBWDMddVVVymljofO+spXvqJmzZqluru71UUXXaT27NnTkMfLL7+sLr/8cnXSSSepnp4e9YlPfEIdPny4DaUhRLbpI0eOqFWrVqlTTz1VdXZ2qnnz5qmrr756zD/wadNkvJBlywDUj3/84/ozLuuMp59+Wl166aVqypQpasaMGeqGG25Qx44da3FpyImOzZ4PHDigli9frk4++WTV3d2t3vzmN6sbb7xRVSqVhnyabc/JqLKEEEIIIYQQQgjxYML5UBNCCCGEEEIIIeMBvlATQgghhBBCCCEB8IWaEEIIIYQQQggJgC/UhBBCCCGEEEJIAHyhJoQQQgghhBBCAuALNSGEEEIIIYQQEgBfqAkhhBBCCCGEkAD4Qk0IIYQQQgghhATAF2pCCCGEEEIIISQAvlATQgghhBBCCCEB8IWaEEIIIYQQQggJgC/UhBBCCCGEEEJIAP8fpxO3eWX5gJQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternate way of visualizing sample tiles from Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# def visualize_image_with_tiles_and_centers(data_loader, img_idx=0):\n", + "# \"\"\"\n", + "# Visualizes an image alongside its corresponding tiles with hit centers overlaid.\n", + "\n", + "# Parameters:\n", + "# - data_loader: DataLoader, the instance of DataLoader to access image and center data.\n", + "# - img_idx: int, the index of the image in the dataset to visualize.\n", + "# \"\"\"\n", + "# # Get the image and corresponding centers\n", + "# image = data_loader.images[img_idx]\n", + "# centers = data_loader.centers[img_idx]\n", + " \n", + "# # Tile the image and map the centers to the tiles\n", + "# tiles, hits_per_tile = data_loader.map_hits_to_tiles(image, centers)\n", + "# num_tiles_per_row = int(image.shape[0] / data_loader.tile_size) # Assuming square grid of tiles\n", + "\n", + "# # Create a figure grid for the original image and its tiles\n", + "# fig, axs = plt.subplots(num_tiles_per_row + 1, num_tiles_per_row, figsize=(15, 15))\n", + "# fig.suptitle(\"Original Image and Tiles with Hit Centers\", fontsize=16)\n", + "\n", + "# # Display the original image with centers\n", + "# axs[0, 0].imshow(image, cmap='gray')\n", + "# axs[0, 0].set_title(\"Original Image\")\n", + "# axs[0, 0].axis('off')\n", + "# for (_, x, y) in centers:\n", + "# axs[0, 0].scatter(x, y, color='red', marker='x') # Plot hit centers on original image\n", + "\n", + "# # Hide unused axes in the first row, if any\n", + "# for j in range(1, num_tiles_per_row):\n", + "# axs[0, j].axis('off')\n", + "\n", + "# # Plot each tile with centers marked\n", + "# for idx, tile in enumerate(tiles):\n", + "# row = idx // num_tiles_per_row + 1\n", + "# col = idx % num_tiles_per_row\n", + "# axs[row, col].imshow(tile, cmap='gray')\n", + "# axs[row, col].set_title(f\"Tile {idx}\")\n", + "# axs[row, col].axis('off')\n", + " \n", + "# # Plot centers within the tile\n", + "# for (x, y) in hits_per_tile[idx]:\n", + "# axs[row, col].scatter(x, y, color='red', marker='x') # Mark center within tile coordinates\n", + "\n", + "# plt.tight_layout()\n", + "# plt.subplots_adjust(top=0.9) # Adjust spacing to fit title\n", + "# plt.show()\n", + "# h = np.random.randint(0, 10000)\n", + "# # Call the function with your DataLoader instance\n", + "# visualize_image_with_tiles_and_centers(data_loader, img_idx=2) # Visualize the first image with centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "d= DataLoader(file_path)\n", + "o =d.images\n", + "f = d.centers[:,:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10000, 50, 2)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAGiCAYAAAC/NyLhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1TUlEQVR4nO3dfXRTZb4v8O9O80JbmpZS2rQKFVBhFGRGxZ6AonOopRyOo+JdS5FZoteDByxzRBC1KjRFx87oGcd54ejcmXvEudelDp5RrxxBGV4HqSgoOqIiZapFbIoUmr6/Jb/7R9OYHfqWNsneO/l+1nrW7t7ZTZ48efllP/v3PFsREQEREZFBmLSuABERUTgYuIiIyFAYuIiIyFAYuIiIyFAYuIiIyFAYuIiIyFAYuIiIyFAYuIiIyFAYuIiIyFAYuIiIyFA0C1wbNmzAeeedh1GjRqGgoADvvfeeVlUhIiID0SRwvfzyy1i1ahXKysrwwQcfYMaMGZg3bx5OnjypRXWIiMhAFC0m2S0oKMDMmTPx29/+FgDg8/kwfvx4/OQnP8GDDz4Y6+oQEZGBmGP9gJ2dnTh48CBKS0sD20wmEwoLC1FZWdnn/3R0dKCjoyOw7vP5cPr0aYwdOxaKokS9zkREFFkigqamJuTl5cFkCq/zL+aB69SpU/B6vcjJyVFtz8nJweeff97n/1RUVKC8vDwW1SMiohg6fvw4zj333LD+xxBZhaWlpfB4PIFSU1OjdZUozpUC8ASV0oF3J6JhSktLC/t/Yn7ElZWVhaSkJNTV1am219XVweFw9Pk/NpsNNpstFtUjAgDsAvB4yDoRRd5wTvfE/IjLarXisssuw/bt2wPbfD4ftm/fDqfTGevqEPWpeJB1ItJOzI+4AGDVqlVYsmQJLr/8clxxxRV4+umn0dLSgjvuuEOL6hCdxeVfbkVP0HL1uycRxZomgevmm2/Gt99+i3Xr1sHtduP73/8+tm7delbCBpFWBECZ/+++c12JSCuajOMaqcbGRqSnp2tdDSIiGiGPxwO73R7W/xgiq5CIiKgXAxcRERkKAxcRERkKA5eOWc1m/DItDXPMZpQD4ORWREQaZRXS0JQrClY2NWFl0Lay/nYmIkoQPOLSsTd9PtX6Vo3qQUSkJwxcOnat16ta5+wNRETsKtS1MvQMhOXsDUSRpQD4mc2GrQCu6eiACz2fNTIGDkAmooRTDmBd0Pp68PyxVjgAmYhoCELPF/P8sbEwcMWYJSkJj5lMuMZqxXowxZ1IC5z939h4jivGHrdacV9bGx7u7ASgnsyViGLD5V/y/LEx8RxXjF2VlIQ9QdmCs8DZx4kocfEclwEUMsU9ohT0nGh3+pfx2vWqAPjNmDG4ZcKEuH6eREPBrsIYc/mX7KKIjHIAa6HOEIvHrlcXgBVnzmDFmTOBbfH4PImGgkdcMdZ7TqsS343TouExmUxovvJK1bZ4zQ5jFhzRdxi4yLBEBOcfO6baFq9dr8yCI/oOuwrJsEQE/1pbi1rEf9ery7+M9+dJNBTMKiQiIs0wq5CIiOIeAxcRERkKAxcRERkKAxcRERkKAxcRERkKAxcRERkKAxcRERkKAxcRERkKAxeRASiKseeDT5RZ/CNNAbAePZc/Yrt9h4GLSOdGjx6N2267Dfn5+VpXZVjOPfdcPH/eeVgHYB96ZvJ3aVslw3jUZMJaAO+A7RaMgYtI55IUBYs+/xxXdHcb8ld3W1sb3jKpv2o4u/3QvBVypM1268FJdol0rrSjA/P278e8oG1GuhZXfX09LqyvV20rBq/8PRR9XXiW7cbARaR7/6+zEw8ErRvxV7fLv+Ts9uFx+ZdsNzUGLgPLzMjAo0lJOORwYPzhw7wwZZyaF7JuxF/dvRdQBYxXdy2x3frGwBVhJgBPpqbiv71eXN3eDheiE0wURcFarxd3NzQA/m6Y4Dc5xQ+Xf8lf3UQ9eD2uCHvcbEZpd3dgfT2iF0yc6MnS6jUL/FVGRMbC63HpwJs+n2o9mucjEvVy7gqAx0wmXJuaivUwXpYdEY0Muwoj7NqQwBXN8xEu/zLRupBcAB72+fBwSwsAdpESJRp2FUaYgp4v1uBgYrgG1jl2kRLFj+F0FfKIK8KYBRR9fXWRsq2JEgcDFxmOy79MtC7SRKAAeDo9HW+bTLjizJm467HIzc1FS0sLGhsbta6KoTFwkeHwqDZ+uQD8m8eDfwvaZvTzl72nD95WFKzMyMDj2dn48KOPNK6VscV9VmF+fj6ysrK0rgYRDUFoFq4RZwkJ5ULPBLl7RfA/PvsM95w5o3GNjC+uA5cC4JHOTswxmw05OSlRoonHIR6hwfe/Q+YfpPDFdVdhOYB/qa3FvwRtM3q3A1E8c/mXsTx/qQD4qdmMLSIo9Hojfl4tNPhOO3ECmyJ4/4kortPhmTZNRIP5aVISHgo6Cor0bDccIjMwzpwRIh67HYgosqJ9Xq03majSv2TQGrm47ip0+ZdMmyai/lzLa14ZTlx3FRIRDUZBz/nwLWBXnhbYVTgAq9mM/7r4Ytx63nnMMCSiAEFPurrRu/J6A7DTv4zn77i47ioMts7nw8LDh7EwaBszDClRKQAet1hQmZ6Oy0+dMvQXNvVwoScAr/OvK0F/x5uEOeL67xheboRI71wAHuzqwuunTmEteP43HoR+p223WDSpRywkTOCKZYah2WTChrFjUfKDH/B6UaRL8ThDRaIL/U6b29WlST1iIWG6Cl3+ZbQzDBVFQYXNhrvr64H6egC8XpQR2CwWPGW348+trZjT1hb3J+g5w378cfmXCZFFLQbk8XgEPd8ruismk0n+5aKLRIBAceqgXiwDlyeTk1WvWbkO6hTNovifo9O/VHRQJ5bELB6PJ+wYkDBdhbHi8/kw8cgR1TYOfB6YxWKB3W6HomjXqfp6R4dqPd67zgQcFEvGlTBdhbH0iNeLbiTIIfsIZWZk4JHubvw1ORmXNjVhHbT5Er02JHmHXWdE+sXAFQW9v2YBfvkN5tGkJNzd0IB7m5sBAD5ocz7Q5V/yxwaR/nHmDNLUlSYT/hp0tMOJkIkSC2fOIMPpq4tuKKxWK8aMGaPpeTEi0ga7CklTLv9yqF10CoDHkpKwx2bDfK8X9ykKuo3XaUBEI8CuQjKUcqinsYn0tZOIKLZ00VXocrmgKIqqTJ06NXB7e3s7SkpKMHbsWIwePRo33XQT6urqIl0NilOc8YGIonKO6+KLL0ZtbW2g7N27N3DbvffeizfeeAObNm3C7t278c0332DhwoUD3BvFmgLgiVGjMDclRXezTPPioEQU8ZkzysrKZMaMGX3e1tDQIBaLRTZt2hTY9tlnnwkAqaysHPJj6HnmjHgo5YBuZ5HgjA8sLPFVdDNzxtGjR5GXl4dJkyZh8eLFqKmpAQAcPHgQXV1dKCwsDOw7depUTJgwAZWVTILWCz13xwk444PeKACez8/Hg3PmRPwIvffo/8acHN0d/ZN2Ip5VWFBQgI0bN2LKlCmora1FeXk5rrrqKnzyySdwu92wWq3IyMhQ/U9OTg7cbne/99nR0YGOoCl5GhsbI11tCsIJWCkcLgC3ffUV8NVXgW1lEbzvNe3tQHt7xO+bDCzsY7QwnTlzRux2u/zhD3+QF154QaxW61n7zJw5U+6///5+76OsrEzzw9l4KEPtZmN3HEs4xQlEbVLpaN43y8hKpL4ndNNVGCwjIwMXXnghqqqq4HA40NnZiYaGBtU+dXV1cDgc/d5HaWkpPB5PoBw/fjzKtY5Pvank+/xLVz/7CdgdR0MXzYQZJuPoV+j3SXksHzzsUBempqYmGTNmjPzqV78KJGe88sorgds///xzAZicEe1iMpnkaouFv179xW63y8T8fHk+P19+lJXFI8sRlGgeofPoX79lFtRHw7OGeT/DOeKKeOBavXq17Nq1S6qrq+Wdd96RwsJCycrKkpMnT4qIyLJly2TChAmyY8cOOXDggDidTnE6nWE9BgNX+MViscjPbTbNswUVRdG8LQDI5MmT5eUpUzRvj7PaB5D1gMwxm2U9+EXNot8SqexjXQSum2++WXJzc8Vqtco555wjN998s1RVVQVub2trk7vvvlvGjBkjKSkpcuONN0ptbW1Yj8HANbxiAuRRRZFZ0ObXq9VqlalTp0pqaqrmbZGUlCRzzGbdHYGGfhn8NClJ8zqxsPRVtDzHxSmfKGZSk5Px26wsvNTQgFlNTXCh552rFT1OH+VEzzmDXnOSkvBXr1er6hBF3XCmfOIkuxQzj3R34/bjx3F70DYtA4XLv9TTNbhCkw8KvV78VZOaEOkXj7goZkKPJnjtrbMp6AmgwcHUcB9QojDwiIt0jQObByfg1bOJBsPARTHj8i/11DVHRMbDrkIiItKMLq7HRaR3CnoyCp3+JSduNR6+homNXYWUcFzoSYMPToXXOg2ewuMCX8NExiMuSjh6vmxLogr3CIqvYWJj4KKEw4lb9ccF9YStFVbrgPuHvmYLTPwqSyTsKqSE4/Ivmd2oH1uh7vZ7Sxn4mMsFYJbTiS8mTULH66/D1doaxdqR3jCrkIg0p8fptyg2OACZiAzJ5V/yKJiGgkdcRESkGY7jIiKiuMfARUREhmL4wJWdlYUP/vmfcfuFF3IEPRFRAjB8ckZpRwd+sHkzngvaxmwkIqL4Zfgjrj81NanWOYKeiCi+Gf6Ii9d4ItKH5ORkTJkyBenp6WhoaMBHH32kdZUoThk+cLn8S47/INLO1KlTcd5552H69On44osv0NDQoHWVKI4ZPnDxirHxj5ez16fg1+VXEyci/z//E9kOB6666ioebVFUcQAy6R6nA9Kn0Ndlw9ixeMbhQHV1NVp1NnegyWSC3W6H2WxGV1cXPB6P1lUiPw5AprjES1joU+jr8EJ9PQ4fPqy7oNXL29WFx5KSsGDMGA6dMTjDdxVS/GMCjj4Z6XXx+Xy4r6UF/9rSgn8N2p6IR+691z5722TCtT6fIbveGbhI91z+JRNw9MXlXxrldQm9dEqiHrk/lZaGlU1NWOvzBbYZLYAzcJHuMQFHn4z2uhjpCDGa3vT5sDJo3YgBnIGLiBKCy780yhFitFzZ0qJaN2IAZ1YhEVEC6R3G8BaAedB+eMlwsgoZuIiISDNMhyciorjHwEVERIbCwEVERIbCwEVERCOWbLPh31NS8KOsrKjPTMJ0eCIiHTDyZNImkwkVo0bhHo8Hq4Om/IrWwGYecRER6YALPTN77PMvXVpWJkw+nw//1dys2hbNgc0MXEREOmD0yaQLvV7VeuhMJZHErkIiIh0w+pRULv8yFjOTcAAyEZEOGPkc10hw5gwiIjIUzpxBRERxj4GLiIgMhYGLqB+9V4p1+pe81DuRPjCrkKgfLvSMpwm+aq7RrhRLFI94xEXUD6OPqyGKVwxcRP14ulg9siaaAyqJaOgYuIj68dENN2DnlVdiFoD10P8UPEmKgmdzcvBPY8bwnBzFNY7jIooTFRYLHuzqCqyvB8/Jkf5xHBdRAtvc3a1a5zk5ilcMXERxoiik84Tn5CheMR1+AL3jeLYgseYOI2Ny+ZexmOSUSEs8xzWARxUFjwQ1D88ZEBFFFs9xRZDZbMau5GTVNp4z0AcFwDPjxuE/fvxjPDV6NEZZrVpXiYhiiF2F/TCbzZgfss1o18eJVy4Ay779Fvi//xcA0Gm14kFNa2RslqQkuABsS0rCDzs72SVOusfA1Y/29nasAdCKniOteeA5A73YCvU0TK93dmpVFcNLSkrCsw4H/ueJE3go6Aq27BInPWPgGoDguy/IfVpWhFSMfqVYvcjPz8dFF12Er7q6gBMnAtvZJU56x3NcZDgu9CTKGGVGC71KS0vD+PHj8YOTJ1XbmUYfGyYAP7NaMS8tjTOdhIlZhUQJLlEvGa+1nyYlqbpnEzVreThZhQxcREQamK0o2Bv09TsLidnlzXR4IiKD4Ewnw8fkDCJKOHroHnX5l5zpJHzsKiSihFMO9ZCKRD2/pAcx6Srcs2cPrrvuOuTl5UFRFLz22muq20UE69atQ25uLpKTk1FYWIijR4+q9jl9+jQWL14Mu92OjIwM3HnnnWhubg63KkREw8KrWxtb2IGrpaUFM2bMwIYNG/q8/YknnsCvf/1rPPvss9i/fz9SU1Mxb948tLe3B/ZZvHgxDh8+jG3btmHz5s3Ys2cP7rrrruE/CyKiMPQ1FpAMREYAgLz66quBdZ/PJw6HQ5588snAtoaGBrHZbPLiiy+KiMinn34qAOT9998P7LNlyxZRFEVOnDgxpMf1eDyCni5pFhYWlrCLAsijiiKzFUXK/eta1ylRi8fjCTv2RDSrsLq6Gm63G4WFhYFt6enpKCgoQGVlT6JnZWUlMjIycPnllwf2KSwshMlkwv79+yNZHSKiPgmAtSJ4RwRl/nUyjohmFbrdbgBATk6OantOTk7gNrfbjezsbHUlzGZkZmYG9gnV0dGBjo6OwHpjY2Mkq01ERAZiiHFcFRUVSE9PD5Tx48drXSUiItJIRAOXw+EAANTV1am219XVBW5zOBw4GTI3Wnd3N06fPh3YJ1RpaSk8Hk+gHD9+PJLVJiIiA4lo4Jo4cSIcDge2b98e2NbY2Ij9+/fD6XQCAJxOJxoaGnDw4MHAPjt27IDP50NBQUGf92uz2WC321WFiIgSU9jnuJqbm1FVVRVYr66uxqFDh5CZmYkJEyZg5cqVeOyxx3DBBRdg4sSJWLt2LfLy8nDDDTcAAL73ve+huLgYS5cuxbPPPouuri6sWLECt9xyC/Ly8iL2xIiIKE6Fm4a4c+fOPlMalyxZIiI9KfFr166VnJwcsdlsMnfuXDly5IjqPurr62XRokUyevRosdvtcscdd0hTU9OQ68B0eBYWFpb4KMNJh+eUT0REpBnODk9ERHGPgYuIiAyFgYuIiAyFgYtIQwp6LrHh9C8VbatDZAi8kCSRRqxWK35us2FlU5Pq2lBlmtWIyBh4xEWkkczMTHQHTUgN8LpQREPBwEWkkYyMDPzIalVt43WhiAbHcVxEGjGZTBhlteLB9nZsQU/QcqFnVCZRohjOOC4GLiIi0gwHIBMRUdxj4CIiIkNh4CIiIkNh4KJBKQAeN5sxLy0Nj5vNMJv4tiEi7XAAMg3KBaC0uxulTU0AAJPVigc7OzWtExElLv50pkGFDop9o6tLk3oQEQEMXDQEoYNii4w3goKI4gi7CmlQLv9yK74bJEtEpBUOQCYiIs1wADIREcU9Bq441HuNpytNJlRYLHyRiSiu8BxXHHIBWAdgnc8H+HwYlZaGe/2p7ERERscf43EoNH19c3e3JvUgIooGBq44FJq+PqetTZN6ECWS5ORk2O12JCcnw8TZZaKKXYVxyOVfMn2dKHauvPJKnH/++fj73/+OAwcOoL6+XusqxS3+LIhDAqAMQKV/abjxDkQGdNXs2Vjt8SC7qgr3NTZC0bpCcYxHXEREETB72zZMfucd/NG/3omeH44UeTziIiKKgEfeeUe1HpokRZHDwEVEFAGhSVGh6xQ57CokIooAl3/JpKjo41yFRESkGc5VSEREcY+Bi4iIDIWBi4iIDIWBi4iIDIVZhQagAHg6PR3ea69F1xtv4MGODs6GQUSaOPfcc2EymdDW1ob6+nr4fL6Y14GBywBcAP7N4wFeeQUA0A6OyCei2FMAPNzRgXczMnCpx4PVAGIfthi4DGEreq6vFbxORBRrLgDLvv0Wy779FgDQAG1+RPMclwFwRD4R6UHoj2atfkTziMsAXP4lR+QTkZb6+hFdqUE9OHMGERENiYKeH87BP6JHGkCGM3MGAxcREWmGUz4REemcAmA9gIUOB35mtfKCk8PAc1xERDHkArAWANxuAEAHOLwlXDziIiKKIb1k5hkZAxcRUQxxeMvIsauQiCiGXP4lh7cMH7MKiYhIM8wqJCKiuMfARURDkpaWhlGjRmldDSIGLiIanKIo+PGPf4yrr75a66oQMXARDYUCoByA079MpEGjqampOH/SJFz59tvIOno04Z4/6Q+zComG4Gc2G+7v6FBdXiZRBo2aTCbc6/Hg1lOncGvQ9kR5/qQ/POIiGoSiKHB///uqbYk0aLSpqQn/59Qp1bZEev6kPwxcRIMQETgOHVJtS7RBoxw0S3rCrkKiIXiwowPtSNxBoy7/MlGfP+kLByATEYXoTcbZgshdd4r6NpwByDziIiIKsTE/H7d99VXPLO5+TEbRD57jIiIK8ZaiTvhnMoq+MHAREYWY8uWXqnUmo+gLuwqJiEK4/Esmo+gTkzOIiEgznB2eiIjiXtiBa8+ePbjuuuuQl5cHRVHw2muvqW6//fbboSiKqhQXq3uIT58+jcWLF8NutyMjIwN33nknmpubR/REiIgoMYQduFpaWjBjxgxs2LCh332Ki4tRW1sbKC+++KLq9sWLF+Pw4cPYtm0bNm/ejD179uCuu+4Kv/ZERJR4ZAQAyKuvvqratmTJErn++uv7/Z9PP/1UAMj7778f2LZlyxZRFEVOnDgxpMf1eDyCnvGALCwscVhGjRolWZmZ8rjZLFclJUk5IIoO6sUS+eLxeMKOPVE5x7Vr1y5kZ2djypQpWL58Oerr6wO3VVZWIiMjA5dffnlgW2FhIUwmE/bv39/n/XV0dKCxsVFViCh+5efn43+PH4/S7m7s8XqxDszso+9EPHAVFxfjj3/8I7Zv346f//zn2L17N+bPnw+v1wsAcLvdyM7OVv2P2WxGZmYm3G53n/dZUVGB9PT0QBk/fnykq01EOlJTU4P/VVOj2sZBwNQr4uO4brnllsDf06dPxyWXXILJkydj165dmDt37rDus7S0FKtWrQqsNzY2MngRxbG2tjYUtLWpthUDqNSmOqQzUR+APGnSJGRlZaGqqgpz586Fw+HAyZMnVft0d3fj9OnTcDgcfd6HzWaDzWaLdlWJSEfK0HMShIOAKVTUx3F9/fXXqK+vR25uLgDA6XSioaEBBw8eDOyzY8cO+Hw+FBQURLs6RGQQgp7gVYnvghgRMIwjrubmZlRVVQXWq6urcejQIWRmZiIzMxPl5eW46aab4HA4cOzYMdx///04//zzMW/ePADA9773PRQXF2Pp0qV49tln0dXVhRUrVuCWW25BXl5e5J4ZERHFp3DTEHfu3NlnSuOSJUuktbVVioqKZNy4cWKxWCQ/P1+WLl0qbrdbdR/19fWyaNEiGT16tNjtdrnjjjukqalpyHVgOjwLCwtLfJThpMNzrkIiItIM5yokIqK4x8BFRESGwsBFRESGwsBFRESGwsDVh5xx4/Bzmw1XmkwoB6BoXSGKGgXAL+12LJ44ka81kUFEfeYMo1EUBc9PmoR5+/fj/qDtZZrViKLJBWBlYyMQNHEzX2sifeMRVwgRwX8cO6baxsk941foa8vXmkj/GLj6cNmpU6r14n720zMTgMfNZix0OPCYycQusH6EvrZGfK2JEg27Cvvg8i+NPLnnepMJpd3dgP9SMV6wC6wvLv/SyK81UaLhzBlxyglgX9D6LPCSEESkP5w5gwLYBUZE8YpdhXHK5V+yC4yI4g27ComISDPsKiQiorjHwEVERIbCwEVERIbCwEVERIbCwEVERIbCwEVERIbCwEVERIbCwEVERIbCwNUHBUA5eub748UFiYj0hVM+9cEFYJ2/AEBKcjLWtLVpVyEiIgrgEVcfzrq4oMJjLiIivWDg6kPoTOpzWls1qQcREZ2NXYV9cPmXnFmdiEh/ODs8UQiz2Yz09HQ0NDTA6/VqXR2iuMbZ4aMoSVHw7ykpuNpiYaZhHFMArAdwbWoqHlUUJPH8JpHusKtwiJ5IScGqlhasDtpWplltKFpcAEq7u4GaGgCAhRmlhqeg53UN7vo3XDcTqfCIawiysrLw/tixqm2hmYcUH0Jf183d3ZrUgyLHhZ6hLfv8y/8YN07T+tDIMXANgdVqxVUtLaptoZmHFB9CX9d/7OrSpB4UOaE/Ro5OnqxJPShy2FU4BN988w1WADgFYIfFgiKfDy6etI9LLv+SGaXDp7euudAfI06PR5N6UOQwcA2RKSkJv8/NxZIlS2C222Fdtw6dnZ0wYFImDUDw3bnLSi0rYmD/npqKVS0tgZlnAG3PB7v8y60AbkpJwRPffqthbSgS2FUYBhFBe3s72niyXtdsFgueGTcOc1NSmAGqge1Wq2pd6/PBvT9GKgHc19qKk6dOaVwjGjExII/HI+h5P8ZFUQApB8TpXyo6qJORyy9SU0WAQCnXQZ0SqawPanu2P8tgxePxhB0D2FWoA4+aTHjY59NN14rRvdrWhlVB61r/4k80ZQBMJhP2pKTgyuZmniekiGNXoQ68FTLIlV+0I3Otz6daZwZobAmAR3w+vN3cjHX+daJI4hGXDhSGZCgWg4kBI+HyL5kZSBSfOFehDugtfZiIKFaGM1chAxcR0RDxR2bkDSdwsauQiGiIXFBfHd1qsaCUs6vEHJMziIiGKDRxKvPWWzWpR6Jj4CIiGqLQDFXZskWTeiQ6dhUSEQ2Ry78MnOM6eVK7yiQwJmcQEZFmeAVkIiKKewxcRERkKAkfuBQA5QCc/iVnEqdQfI8Q6UvCJ2c8mZKC1a2tnOCW+lUOYC3A9wiRTiT8EdfbJnUTcIJbCmYymbBDZ9eXIkp0CR+4Zjc3q9Y5kzgFM5vNWJCUpNrG9wiRthK+q9DlX3ImcepLZ2cnHgDQrijYCqBIhO8RIo1xHBcREWmG47iIiCjuMXAREZGhMHAREZGhMHARka5YzWb8NCkJ/zhqFAd8U58SPquQiPTlydRU/JvHg4e83sA2DvimYDziIiJdebWtTbXOAd8UioEriMViwZj0dDw1ejSKRo9mNwVFjQLgMZMJN+bk4DGTie+zID/s7FStc8A3hWJXYRC73Y5fpKZiSU0N7g3azm4KijQXgId9PqCuDgDgBd9nvVz+JScFoP6EdcRVUVGBmTNnIi0tDdnZ2bjhhhtw5MgR1T7t7e0oKSnB2LFjMXr0aNx0002o8384e9XU1GDBggVISUlBdnY21qxZg+7u7pE/mxFqaGjA8yF1ZTcFRUPo+4rvs+8IeoJ4pX9puBkS4lBmZibGjh2rdTUCwgpcu3fvRklJCd59911s27YNXV1dKCoqQktLS2Cfe++9F2+88QY2bdqE3bt345tvvsHChQsDt3u9XixYsACdnZ3Yt28fnn/+eWzcuBHr1q3r6yFjyuv14pqODtU2dlNQNIS+r/g+I71RADyqKPinjAys83qRbLNpXaXvyAicPHlSAMju3btFRKShoUEsFots2rQpsM9nn30mAKSyslJERN58800xmUzidrsD+zzzzDNit9ulo6NjSI/r8XgEPT/EIl4UQMoBcfqXSpQeZ6DHf1RRZJZGj88Su9dZy/cZC8tgpRwQCSpPp6dH5XE8Hk/YsWdEgevo0aMCQP72t7+JiMj27dsFgJw5c0a134QJE+Spp54SEZG1a9fKjBkzVLf//e9/FwDywQcf9Pk47e3t4vF4AuX48eOav6jRKhUWi+rNUq6DOrGwsCRecUIduGYrSlQeZziBa9hZhT6fDytXrsTs2bMxbdo0AIDb7YbVakVGRoZq35ycHLjd7sA+OTk5Z93ee1tfKioqkJ6eHijjx48fbrV1j+c+iEgPQruvi3Q0H/uwA1dJSQk++eQTvPTSS5GsT59KS0vh8XgC5fjx41F/TK38Y1eXap3nPohICy4A6wHM8i9dWlYmxLDS4VesWIHNmzdjz549OPfccwPbHQ4HOjs70dDQoDrqqqurg8PhCOzz3nvvqe6vN+uwd59QNpsNNj2dGIwil3/JVGAi0pLguyEalVpWpC/h9Cv6fD4pKSmRvLw8+eKLL866vTc545VXXgls+/zzzwU4Ozmjrq4usM/vfvc7sdvt0t7ePqR6RDM5g4WFhYUldiXqyRnLly+X9PR02bVrl9TW1gZKa2trYJ9ly5bJhAkTZMeOHXLgwAFxOp3idDoDt3d3d8u0adOkqKhIDh06JFu3bpVx48ZJaWnpkOvBwHV2UQB5MjlZfpSVNewsNbPZLGazWfPnwsLCkjgl6oGrvwd+7rnnAvu0tbXJ3XffLWPGjJGUlBS58cYbpba2VnU/X375pcyfP1+Sk5MlKytLVq9eLV1dXUOuBwPX2SU0dTXcbEQFkF+mpY0o8LGwsLCEW4YTuBR/QDKUxsZGpKena10NXXEC2Be0Pgvh9UuXAwgeAv6YomCt8d4aEZWZmYnu7m40NjZqXRWiuOXxeGC328P6H06yGydGOhNDaNr9W0riTvtqMpkwOiUF5SK4xmrlZMtEOsNJduOEy78cbjZiaKC71ufD3hHWyahGjRqFJ1JTsfzbb7EiaHuZZjUiomDsKiQAPUcULqgDn+HeGBGiKArmmM3YFTSmLtyu10SRmpqKRYsWYefOnTh27JjW1dFUUlISFEXRxYThRsKuQho2AWfk7iUiHAg+BAqAhzs6kPfll/jJqVMJ3Z2qAPhDXh7umzUrKl3LiqLAZNLf17XVaoXFYkFSUhIyMzMxatSo2Dxw2OkcOsCsQpZoF06CO3gZaSZrPJVotkXvxNtXWyy6eC8GfzZ+kZoq2VlZkpGRIf/wD/8gubm5Yd9fzCfZ1QoDFwuL9iV0ElanDuoUj22htx8IofVpXrVK3G63nDp1StasWRN28BpO4GJyBhENS1+ZrLE6D6gAeG7CBLybkYHcjz/W/JxsNNtiK9RDVbSeeDu0PpuamvD1738PADhw4IDq+ozRwsBFRMPi8i+1mFfTBWBJTQ2W1NQEtpXF8PFDufzLaLSFlj8Q+hJan5rf/z7mbc+sQiIynJEOuDeS4WT8RjNLONL3PZysQh5xEZHh6O0oJJoE4c/S7kJPd15wl16kjoqGU59IY+AiIsNx+Ze8/E/f9HZeLNL0NzCAiGgQvb/6tRx3qKBnjk+nf6mncWwjnQJO73jERUQ0DC6ou+PMSUl42OvVrkJBXP5lvB6RMjmDiGgYQhNEfmi1Yldnp1bVMSxO+UREFCOh3W8/ZNCKGXYVEhENg8u/jNfuOD1jVyEREfWrNwnlLUVBkUjEZynhOC4iIoooF4C1gOqK6FrOUgLwHBcREQ0gdAyYHsaEMXAREVG/9DgmjF2FRETUL5d/qacklIRKzuDl6YmI9IXJGYNwQT3S3aQoqhOORESkfwl1jiv0pOK2pCRN6kFERMOXUIEr9KTi3O5uTepBRETDl3BdhQp6jrQKvV5dnGQkIqLwJFRyBhER6Qsn2SUiorjHwEVERIbCwEVERIbCwEVERIbCwKWhrKwspKWlaV0NIiJDYeDSgNVqxbixY/HLtDT8aNw4lKMnTZ+IiAaXUOO49MJiscAF4MfV1fhx0Hatr3FDRGQEPOLSQEtLC16or1dt08M1boiIjICBSyPzQtb1cI0bIiIjYFehRlz+pZ6ucUNEZASc8omIIorXvaNw8HpcRKS5Ny69FAs++CBw3TuAiUcUWTzHRUSRVaw+Y8vEI4o0Bi4iiqjpJ06o1pl4RJHGwEVEEVW4dy9+k5GBWQDWg4lHFHlMziAiFQXAz0eNQvOVVyLr4EE80tWFxuZmratFcYrJGUQ0Yi4Aa9rbgb/8BQBgyszECk1rRKTGrkIiUglNpnjZ49GkHkT9YeAiIpXQZIpCr1eTehD1J6G6Ck0AyhUFb5tMKPR6OTCSqA8u/5KzupBeJUxyhqIoeDI5GatbWwPb1oMDI4mItDSc5IyE6SoUEWzu7lZt48BIIiLjSZjABQA/7OxUrXNgJBmVzWLB42YzfmizYT14IVJKLAl1jsvlX7Lvnozu6YwMLPv2W5T6exEE7PamxJFQgSv4w12pZUV0atGiRRARvPTSS1pXhQbxXy0tWBa0zm5vSiQJ1VVI/VMALP7iC1za3o7HzWa+MXTuqqAkI4Dd3gOxWCywWq1aV4MiKKGOuKh/LgALDh7EgoMHAQA+kwmP+Hya1on65/Iv2e09uDHp6Sjt6MCfOjt5fbA4kTDp8DQwJ4B9QeuzQ9aJjOo3Y8ZgxZkzgXUOg9EXpsPTsIV2Nc3TpBZEkbctKUm1zvOBxseuQgLArieKX5edOqVaLwaTs4yOXYVEFNcU9PwQC/5RZrgvvTg2nK5CBi4iItIMz3EREVHcY+AiIiJDCStwVVRUYObMmUhLS0N2djZuuOEGHDlyRLXPNddcA0VRVGXZsmWqfWpqarBgwQKkpKQgOzsba9asQXfIBLhERER9CSurcPfu3SgpKcHMmTPR3d2Nhx56CEVFRfj000+Rmpoa2G/p0qVYv359YD0lJSXwt9frxYIFC+BwOLBv3z7U1tbitttug8ViweOPPx6Bp0RERHFNRuDkyZMCQHbv3h3YdvXVV8s999zT7/+8+eabYjKZxO12B7Y988wzYrfbpaOjY0iP6/F4BD2JQSwsLCwswywKIOWAOP1LRYM6eDyesGPPiM5xeTweAEBmZqZq+wsvvICsrCxMmzYNpaWlaA2aV62yshLTp09HTk5OYNu8efPQ2NiIw4cP9/k4HR0daGxsVBUiIhoZF4B16JklZx2MM35z2AOQfT4fVq5cidmzZ2PatGmB7bfeeivy8/ORl5eHjz/+GA888ACOHDmCP//5zwAAt9utCloAAutut7vPx6qoqEB5eflwq0pERH3Yip6AFbxuCGEfo/ktW7ZM8vPz5fjx4wPut337dgEgVVVVIiKydOlSKSoqUu3T0tIiAOTNN9/s8z7a29vF4/EEyvHjxzU/xGZhYYnPoofus1iVckAkqJRrUIfhdBUO64hrxYoV2Lx5M/bs2YNzzz13wH0LCgoAAFVVVZg8eTIcDgfee+891T51dXUAAIfD0ed92Gw22Gy24VSViCgsLvQchQQfiZRpU5Woc/mXhpvqLZwo5/P5pKSkRPLy8uSLL74Y0v/s3btXAMhHH30kIt8lZ9TV1QX2+d3vfid2u13a29uHdJ9MzmBhYYlWcUJ9FOLUQZ3iuQzniCuswLV8+XJJT0+XXbt2SW1tbaC0traKiEhVVZWsX79eDhw4INXV1fL666/LpEmTZM6cOYH76O7ulmnTpklRUZEcOnRItm7dKuPGjZPS0tIh14OBi4WFJVpFD91niVSiHrj6e+DnnntORERqampkzpw5kpmZKTabTc4//3xZs2bNWRX78ssvZf78+ZKcnCxZWVmyevVq6erqGnI9GLhYwi0mk0lMJpPm9WDRf0mkc1x6KMMJXJxkN0GNTknBpmnT8Lzbje/V1MT1jNkKgF+MHo09KSm4qqUF97e2wmu8tz1RXBrOJLuGvB6XAWOt7jykKJj13nuY5V9vB1ChZYWi6EEAdzY3487mZgDAGUXBY9pWiYj8hvN9bsgjrq+//hrjx4/XuhpERDRCx48fHzQ7PZQhA5fP58ORI0dw0UUX4fjx42EfZiaCxsZGjB8/nu3TD7bPwNg+g2MbDWyw9hERNDU1IS8vDyZTeJM4GbKr0GQy4ZxzzgEA2O12vmkGwPYZGNtnYGyfwbGNBjZQ+ww3V4HX4yIiIkNh4CIiIkMxbOCy2WwoKyvjVFD9YPsMjO0zMLbP4NhGA4tm+xgyOYOIiBKXYY+4iIgoMTFwERGRoTBwERGRoTBwERGRoRgycG3YsAHnnXceRo0ahYKCgrMuTJkoXC4XFEVRlalTpwZub29vR0lJCcaOHYvRo0fjpptuCly0M17t2bMH1113HfLy8qAoCl577TXV7SKCdevWITc3F8nJySgsLMTRo0dV+5w+fRqLFy+G3W5HRkYG7rzzTjT75zk0usHa5/bbbz/rPVVcXKzaJ17bp6KiAjNnzkRaWhqys7Nxww034MiRI6p9hvKZqqmpwYIFC5CSkoLs7GysWbMG3d3dsXwqUTOUNrrmmmvOeg8tW7ZMtc9I28hwgevll1/GqlWrUFZWhg8++AAzZszAvHnzcPLkSa2rpomLL74YtbW1gbJ3797Abffeey/eeOMNbNq0Cbt378Y333yDhQsXaljb6GtpacGMGTOwYcOGPm9/4okn8Otf/xrPPvss9u/fj9TUVMybNw/t7e2BfRYvXozDhw9j27ZtgSt933XXXbF6ClE1WPsAQHFxseo99eKLL6puj9f22b17N0pKSvDuu+9i27Zt6OrqQlFREVpaWgL7DPaZ8nq9WLBgATo7O7Fv3z48//zz2LhxI9atW9fXQxrOUNoIAJYuXap6Dz3xxBOB2yLSRmFfCEVjV1xxhZSUlATWvV6v5OXlSUVFhYa10kZZWZnMmDGjz9saGhrEYrHIpk2bAts+++wzASCVlZUxqqG2AMirr74aWPf5fOJwOOTJJ58MbGtoaBCbzSYvvviiiIh8+umnAkDef//9wD5btmwRRVHkxIkTMat7LIS2j4jIkiVL5Prrr+/3fxKpfU6ePCkAZPfu3SIytM9U7xXe3W53YJ9nnnlG7Ha7dHR0xPYJxEBoG4mIXH311XLPPff0+z+RaCNDHXF1dnbi4MGDKCwsDGwzmUwoLCxEZWWlhjXTztGjR5GXl4dJkyZh8eLFqKmpAQAcPHgQXV1dqraaOnUqJkyYkLBtVV1dDbfbrWqT9PR0FBQUBNqksrISGRkZuPzyywP7FBYWwmQyYf/+/TGvsxZ27dqF7OxsTJkyBcuXL0d9fX3gtkRqH4/HAwDIzMwEMLTPVGVlJaZPn46cnJzAPvPmzUNjYyMOHz4cw9rHRmgb9XrhhReQlZWFadOmobS0FK2trYHbItFGhppk99SpU/B6vaonDAA5OTn4/PPPNaqVdgoKCrBx40ZMmTIFtbW1KC8vx1VXXYVPPvkEbrcbVqsVGRkZqv/JycmB2+3WpsIa633efb1/em9zu93Izs5W3W42m5GZmZkQ7VZcXIyFCxdi4sSJOHbsGB566CHMnz8flZWVSEpKSpj28fl8WLlyJWbPno1p06YBwJA+U263u8/3V+9t8aSvNgKAW2+9Ffn5+cjLy8PHH3+MBx54AEeOHMGf//xnAJFpI0MFLlKbP39+4O9LLrkEBQUFyM/Px5/+9CckJydrWDMyqltuuSXw9/Tp03HJJZdg8uTJ2LVrF+bOnathzWKrpKQEn3zyieqcMan110bB5zunT5+O3NxczJ07F8eOHcPkyZMj8tiG6irMyspCUlLSWVk8dXV1cDgcGtVKPzIyMnDhhReiqqoKDocDnZ2daGhoUO2TyG3V+7wHev84HI6zEn26u7tx+vTphGy3SZMmISsrC1VVVQASo31WrFiBzZs3Y+fOnaoLHA7lM+VwOPp8f/XeFi/6a6O+FBQUAIDqPTTSNjJU4LJarbjsssuwffv2wDafz4ft27fD6XRqWDN9aG5uxrFjx5Cbm4vLLrsMFotF1VZHjhxBTU1NwrbVxIkT4XA4VG3S2NiI/fv3B9rE6XSioaEBBw8eDOyzY8cO+Hy+wAcwkXz99deor69Hbm4ugPhuHxHBihUr8Oqrr2LHjh2YOHGi6vahfKacTif+9re/qYL7tm3bYLfbcdFFF8XmiUTRYG3Ul0OHDgGA6j004jYaZjKJZl566SWx2WyyceNG+fTTT+Wuu+6SjIwMVYZKoli9erXs2rVLqqur5Z133pHCwkLJysqSkydPiojIsmXLZMKECbJjxw45cOCAOJ1OcTqdGtc6upqamuTDDz+UDz/8UADIU089JR9++KF89dVXIiLys5/9TDIyMuT111+Xjz/+WK6//nqZOHGitLW1Be6juLhYfvCDH8j+/ftl7969csEFF8iiRYu0ekoRNVD7NDU1yX333SeVlZVSXV0tf/nLX+TSSy+VCy64QNrb2wP3Ea/ts3z5cklPT5ddu3ZJbW1toLS2tgb2Gewz1d3dLdOmTZOioiI5dOiQbN26VcaNGyelpaVaPKWIG6yNqqqqZP369XLgwAGprq6W119/XSZNmiRz5swJ3Eck2shwgUtE5De/+Y1MmDBBrFarXHHFFfLuu+9qXSVN3HzzzZKbmytWq1XOOeccufnmm6Wqqipwe1tbm9x9990yZswYSUlJkRtvvFFqa2s1rHH07dy5UwCcVZYsWSIiPSnxa9eulZycHLHZbDJ37lw5cuSI6j7q6+tl0aJFMnr0aLHb7XLHHXdIU1OTBs8m8gZqn9bWVikqKpJx48aJxWKR/Px8Wbp06Vk/CuO1ffpqFwDy3HPPBfYZymfqyy+/lPnz50tycrJkZWXJ6tWrpaurK8bPJjoGa6OamhqZM2eOZGZmis1mk/PPP1/WrFkjHo9HdT8jbSNe1oSIiAzFUOe4iIiIGLiIiMhQGLiIiMhQGLiIiMhQGLiIiMhQGLiIiMhQGLiIiMhQGLiIiMhQGLiIiMhQGLiIiMhQGLiIiMhQGLiIiMhQ/j8kJ+jw0w4wAgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(o[2], cmap='gray')\n", + "plt.scatter(f[2][:,0], f[2][:,1], color='red', marker='x', s=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(80000, 13, 1)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f[:,:,1:].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model definition" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "# Define the model\n", + "def create_model(input_shape=(8, 8, 1), max_hits=5):\n", + " model = tf.keras.Sequential([\n", + " tf.keras.layers.Conv2D(64, (3, 3), activation='relu', input_shape=input_shape),\n", + " # tf.keras.layers.MaxPooling2D((2, 2)),\n", + " # tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(128, activation='relu'),\n", + " tf.keras.layers.Dense(max_hits * 2) # Predict x and y for each hit, so output shape is (max_hits * 2,)\n", + " ])\n", + " return model\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Custom Loss Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(a) Sorting Algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort both y_true and y_pred based on Euclidean distances\n", + " y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + " y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + " # Compute the difference\n", + " diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " return loss\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize model" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"sequential_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 2, 2, 64)       │           640 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (Flatten)             │ (None, 256)            │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (Dense)                 │ (None, 128)            │        32,896 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (Dense)                 │ (None, 10)             │         1,290 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m2\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m640\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m32,896\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m1,290\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 34,826 (136.04 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m34,826\u001b[0m (136.04 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 34,826 (136.04 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m34,826\u001b[0m (136.04 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "with strategy.scope():\n", + " model = create_model()\n", + " model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate = 0.001), loss=euclidean_sorted_custom_loss(exponent=2.0))\n", + " model.summary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Set up learning rate scheduler\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(\n", + " monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Train model" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 3.2752e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-17 14:57:14.067754: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-17 14:57:14.067900: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "2024-11-17 14:57:14.067981: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731873435.079733 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.079915 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.080604 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.085880 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.085901 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.086057 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.086358 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.087033 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.087455 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.087498 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.087773 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.088288 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.088398 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.088711 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.088882 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.090071 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.090114 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.090150 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.090911 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.090946 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.090987 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.092213 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.092243 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.092331 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.093278 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.093335 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.093458 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.093820 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.093949 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.094153 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.094390 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.094590 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.094819 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.095084 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.095238 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.095549 1265123 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.095712 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.096045 1265170 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.101224 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.108558 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.115948 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.116265 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.116610 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.117005 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731873435.117335 1265190 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m117s\u001b[0m 14ms/step - loss: 3.2752e-04 - val_loss: 3.2614e-04 - learning_rate: 0.0010\n", + "Epoch 2/20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-17 14:57:27.962524: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8191/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 3.2349e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-17 14:59:04.702982: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m111s\u001b[0m 13ms/step - loss: 3.2349e-04 - val_loss: 3.2373e-04 - learning_rate: 0.0010\n", + "Epoch 3/20\n", + "\u001b[1m8189/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 3.2143e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-17 15:01:10.920630: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m112s\u001b[0m 13ms/step - loss: 3.2143e-04 - val_loss: 3.2139e-04 - learning_rate: 0.0010\n", + "Epoch 4/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m110s\u001b[0m 13ms/step - loss: 3.2004e-04 - val_loss: 3.2032e-04 - learning_rate: 0.0010\n", + "Epoch 5/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m112s\u001b[0m 13ms/step - loss: 3.1890e-04 - val_loss: 3.1965e-04 - learning_rate: 0.0010\n", + "Epoch 6/20\n", + "\u001b[1m8188/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 3.1780e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-17 15:06:31.786783: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m113s\u001b[0m 14ms/step - loss: 3.1780e-04 - val_loss: 3.1868e-04 - learning_rate: 0.0010\n", + "Epoch 7/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m112s\u001b[0m 13ms/step - loss: 3.1691e-04 - val_loss: 3.1786e-04 - learning_rate: 0.0010\n", + "Epoch 8/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m111s\u001b[0m 13ms/step - loss: 3.1621e-04 - val_loss: 3.1750e-04 - learning_rate: 0.0010\n", + "Epoch 9/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m113s\u001b[0m 14ms/step - loss: 3.1560e-04 - val_loss: 3.1621e-04 - learning_rate: 0.0010\n", + "Epoch 10/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m114s\u001b[0m 14ms/step - loss: 3.1509e-04 - val_loss: 3.1603e-04 - learning_rate: 0.0010\n", + "Epoch 11/20\n", + "\u001b[1m8191/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 12ms/step - loss: 3.1467e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-17 15:15:52.732002: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 11: ReduceLROnPlateau reducing learning rate to 0.0009000000427477062.\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m110s\u001b[0m 13ms/step - loss: 3.1467e-04 - val_loss: 3.1560e-04 - learning_rate: 0.0010\n", + "Epoch 12/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m112s\u001b[0m 13ms/step - loss: 3.1386e-04 - val_loss: 3.1508e-04 - learning_rate: 9.0000e-04\n", + "Epoch 13/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m107s\u001b[0m 13ms/step - loss: 3.1351e-04 - val_loss: 3.1498e-04 - learning_rate: 9.0000e-04\n", + "Epoch 14/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m111s\u001b[0m 13ms/step - loss: 3.1315e-04 - val_loss: 3.1486e-04 - learning_rate: 9.0000e-04\n", + "Epoch 15/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m104s\u001b[0m 13ms/step - loss: 3.1282e-04 - val_loss: 3.1495e-04 - learning_rate: 9.0000e-04\n", + "Epoch 16/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m112s\u001b[0m 14ms/step - loss: 3.1249e-04 - val_loss: 3.1458e-04 - learning_rate: 9.0000e-04\n", + "Epoch 17/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m103s\u001b[0m 12ms/step - loss: 3.1216e-04 - val_loss: 3.1434e-04 - learning_rate: 9.0000e-04\n", + "Epoch 18/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m113s\u001b[0m 14ms/step - loss: 3.1179e-04 - val_loss: 3.1437e-04 - learning_rate: 9.0000e-04\n", + "Epoch 19/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m107s\u001b[0m 13ms/step - loss: 3.1147e-04 - val_loss: 3.1392e-04 - learning_rate: 9.0000e-04\n", + "Epoch 20/20\n", + "\u001b[1m8192/8192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m111s\u001b[0m 13ms/step - loss: 3.1114e-04 - val_loss: 3.1355e-04 - learning_rate: 9.0000e-04\n" + ] + } + ], + "source": [ + "\n", + "# Train the model\n", + "history = model.fit(\n", + " train_dataset, # Dataset prepared in your previous code\n", + " validation_data=val_dataset,\n", + " epochs=20,\n", + " batch_size=4000,callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training Results" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# loaded_model = tf.keras.models.load_model('/home/da886/Final Electron counting project/Post Training Analysis/20KFixed_Mixed_5_64by64_Randomindex.keras')\n", + "model.save('/home/da886/Electron Counting Tiling approach/Trained weights/10KFixed_100_256by256_4x4TilesRandomindex.keras')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Post Training Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def predict_and_visualize(model, data_loader, dataset, img_idx, tile_size=4, max_hits_per_tile=5, threshold=1):\n", + " \"\"\"\n", + " Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access image and tile information.\n", + " - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + " \"\"\"\n", + " # Calculate the grid size based on the image and tile size\n", + " grid_size = 256 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + " # Initialize variables to store the cumulative number of images processed\n", + " cumulative_images = 0\n", + "\n", + " # Iterate over the dataset to find the batch containing the desired image index\n", + " for batch_images, batch_true_centers in dataset:\n", + " # Calculate the number of images in the current batch\n", + " num_tiles_in_batch = batch_images.shape[0]\n", + " num_images_in_batch = num_tiles_in_batch // (grid_size ** 2)\n", + "\n", + " # Check if the desired image is in the current batch\n", + " if cumulative_images + num_images_in_batch > img_idx:\n", + " # Calculate the index of the image within the batch\n", + " batch_img_idx = img_idx - cumulative_images\n", + "\n", + " # Extract the tiles and true centers for the desired image\n", + " start_idx = batch_img_idx * grid_size**2\n", + " end_idx = (batch_img_idx + 1) * grid_size**2\n", + " image_tiles = batch_images[start_idx:end_idx]\n", + " true_centers_tiles = batch_true_centers[start_idx:end_idx]\n", + " break\n", + "\n", + " cumulative_images += num_images_in_batch\n", + " else:\n", + " # If we exit the loop normally, the image index was out of range\n", + " raise IndexError(f\"Image index {img_idx} is out of range.\")\n", + "\n", + " # Make predictions on the tiles of the chosen image\n", + " predictions = model.predict(image_tiles)\n", + "\n", + " # Reshape predictions for visualization\n", + " predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + " ) # 8x8 grid for a 64x64 image\n", + "\n", + " # Visualize the original image with both true and filtered predicted hit centers\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(15, 15))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + " # Overlay the tile boundaries\n", + " for i in range(1, grid_size):\n", + " # Horizontal lines\n", + " ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " # Vertical lines\n", + " ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true and filtered predicted centers on the reconstructed image\n", + " for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " # Plot true centers in green\n", + " true_tile_centers = true_centers_tiles[tile_idx].numpy().reshape(-1, 2)\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='green', marker='x', s=40,\n", + " label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot filtered predicted centers in red\n", + " predicted_tile_centers = predicted_centers[tile_idx]\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='red', marker='o', s=30,\n", + " label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "Image index 444 is out of range.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[26], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m t \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1000\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m \u001b[43mpredict_and_visualize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimg_idx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m444\u001b[39;49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[21], line 46\u001b[0m, in \u001b[0;36mpredict_and_visualize\u001b[0;34m(model, data_loader, dataset, img_idx, tile_size, max_hits_per_tile, threshold)\u001b[0m\n\u001b[1;32m 43\u001b[0m cumulative_images \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m num_images_in_batch\n\u001b[1;32m 44\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 45\u001b[0m \u001b[38;5;66;03m# If we exit the loop normally, the image index was out of range\u001b[39;00m\n\u001b[0;32m---> 46\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mImage index \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mimg_idx\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m is out of range.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 48\u001b[0m \u001b[38;5;66;03m# Make predictions on the tiles of the chosen image\u001b[39;00m\n\u001b[1;32m 49\u001b[0m predictions \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mpredict(image_tiles)\n", + "\u001b[0;31mIndexError\u001b[0m: Image index 444 is out of range." + ] + } + ], + "source": [ + "t = np.random.randint(0, 1000)\n", + "predict_and_visualize(model, data_loader, train_dataset, img_idx=444)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Electron Counting Tiling approach/256 by 256 images.ipynb b/Electron Counting Tiling approach/256 by 256 images.ipynb new file mode 100644 index 0000000..a4cf519 --- /dev/null +++ b/Electron Counting Tiling approach/256 by 256 images.ipynb @@ -0,0 +1,3324 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 17:57:48.084406: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-25 17:57:48.098635: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-25 17:57:48.112407: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-25 17:57:48.116552: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-25 17:57:48.128496: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-25 17:57:48.761118: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-25 17:57:50.203760: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-25 17:57:50.205263: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79196 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=2):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:1500])\n", + " centers = np.array(f['centers_training'][:1500])\n", + " \n", + " # Debug: Print the raw centers before any processing\n", + " # print(\"Raw centers for first image:\", centers[0])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + " # def tile_image(self, image):\n", + " # # Calculate the padding required for rows and columns\n", + " # pad_rows = (self.tile_size - image.shape[0] % self.tile_size) % self.tile_size\n", + " # pad_cols = (self.tile_size - image.shape[1] % self.tile_size) % self.tile_size\n", + " \n", + " # # Pad the image with zeros (or a constant value, e.g., the mean pixel value)\n", + " # padded_image = np.pad(image, \n", + " # ((0, pad_rows), (0, pad_cols)), \n", + " # mode='constant', constant_values=0)\n", + " \n", + " # # Tile the padded image\n", + " # tiles = []\n", + " # for i in range(0, padded_image.shape[0], self.tile_size):\n", + " # for j in range(0, padded_image.shape[1], self.tile_size):\n", + " # tile = padded_image[i:i + self.tile_size, j:j + self.tile_size]\n", + " # tiles.append(tile)\n", + " \n", + " # return np.array(tiles)\n", + "\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " # Debug: Print hits mapped to tiles\n", + " # print(\"Mapped hits per tile for first image:\", hits_per_tile)\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # print(\"Tiled centers before padding:\", tiled_centers[0])\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + " def pad_hits(self, centers):\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + "\n", + " # print(\"Padded centers for first image:\", padded_centers[0])\n", + " return np.array(padded_centers)\n", + " \n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1] based on tile size\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " # Debugging normalized and padded centers\n", + " # print(\"Normalized and padded centers for the first image:\", padded_centers[0])\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + "\n", + " \n", + " def reconstruct_image_from_tiles(self, tiles, tile_size, num_tiles_per_row=None):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles).\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image grid.\n", + " If None, it defaults to sqrt of the number of tiles (assuming a square layout).\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " # If num_tiles_per_row is not provided, calculate it as the square root of the number of tiles\n", + " if num_tiles_per_row is None:\n", + " num_tiles_per_row = int(np.sqrt(len(tiles)))\n", + " \n", + " # Initialize an empty array for the reconstructed image\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " \n", + " # Place each tile in the correct position in the reconstructed image\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " \n", + " return reconstructed_image\n", + " \n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + " \n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and pad if necessary\n", + " flat_centers = []\n", + " for img_centers in centers:\n", + " for tile_centers in img_centers:\n", + " # Convert tile_centers to a list of tuples to handle padding consistently\n", + " tile_centers = list(tile_centers)\n", + " if len(tile_centers) == 0:\n", + " tile_centers = [(0, 0)] * max_hits_per_tile\n", + " else:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " tile_centers = tile_centers[:max_hits_per_tile] + [(0, 0)] * (max_hits_per_tile - len(tile_centers))\n", + "\n", + " # Flatten each (x, y) hit into a single list\n", + " flat_centers.append([coord for hit in tile_centers for coord in hit])\n", + "\n", + " flat_centers = np.array(flat_centers)\n", + " return flat_images, flat_centers\n", + "\n", + "\n", + "# Split data into training and validation sets\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " # Normalize and flatten data from data loader\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten the dataset\n", + " train_images_flat, train_centers_flat = flatten_dataset(train_images, train_centers, tile_size=8, max_hits_per_tile=2)\n", + " val_images_flat, val_centers_flat = flatten_dataset(val_images, val_centers, tile_size=8, max_hits_per_tile=2)\n", + "\n", + " # Create TensorFlow datasets for training and validation\n", + " batch_size = 4000\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_200_256by256_95indexNoNoise.h5' ###for training\n", + "# file_path ='/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5' ###for testing\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=2)\n", + "\n", + "# images, centers = data_loader.normalize_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10000, 1024, 5, 2)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create Datasets for Training/Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate the datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((1200, 1024, 8, 8), (300, 1024, 8, 8), (1200, 1024, 2, 2), (300, 1024, 2, 2))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize sample tiles from the dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternate way of visualizing sample tiles from Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "# def visualize_image_with_tiles_and_centers(data_loader, img_idx=0):\n", + "# \"\"\"\n", + "# Visualizes an image alongside its corresponding tiles with hit centers overlaid.\n", + "\n", + "# Parameters:\n", + "# - data_loader: DataLoader, the instance of DataLoader to access image and center data.\n", + "# - img_idx: int, the index of the image in the dataset to visualize.\n", + "# \"\"\"\n", + "# # Get the image and corresponding centers\n", + "# image = data_loader.images[img_idx]\n", + "# centers = data_loader.centers[img_idx]\n", + " \n", + "# # Tile the image and map the centers to the tiles\n", + "# tiles, hits_per_tile = data_loader.map_hits_to_tiles(image, centers)\n", + "# num_tiles_per_row = int(image.shape[0] / data_loader.tile_size) # Assuming square grid of tiles\n", + "\n", + "# # Create a figure grid for the original image and its tiles\n", + "# fig, axs = plt.subplots(num_tiles_per_row + 1, num_tiles_per_row, figsize=(15, 15))\n", + "# fig.suptitle(\"Original Image and Tiles with Hit Centers\", fontsize=16)\n", + "\n", + "# # Display the original image with centers\n", + "# axs[0, 0].imshow(image, cmap='gray')\n", + "# axs[0, 0].set_title(\"Original Image\")\n", + "# axs[0, 0].axis('off')\n", + "# for (_, x, y) in centers:\n", + "# axs[0, 0].scatter(x, y, color='red', marker='x') # Plot hit centers on original image\n", + "\n", + "# # Hide unused axes in the first row, if any\n", + "# for j in range(1, num_tiles_per_row):\n", + "# axs[0, j].axis('off')\n", + "\n", + "# # Plot each tile with centers marked\n", + "# for idx, tile in enumerate(tiles):\n", + "# row = idx // num_tiles_per_row + 1\n", + "# col = idx % num_tiles_per_row\n", + "# axs[row, col].imshow(tile, cmap='gray')\n", + "# axs[row, col].set_title(f\"Tile {idx}\")\n", + "# axs[row, col].axis('off')\n", + " \n", + "# # Plot centers within the tile\n", + "# for (x, y) in hits_per_tile[idx]:\n", + "# axs[row, col].scatter(x, y, color='red', marker='x') # Mark center within tile coordinates\n", + "\n", + "# plt.tight_layout()\n", + "# plt.subplots_adjust(top=0.9) # Adjust spacing to fit title\n", + "# plt.show()\n", + "# h = np.random.randint(0, 10000)\n", + "# # Call the function with your DataLoader instance\n", + "# visualize_image_with_tiles_and_centers(data_loader, img_idx=2) # Visualize the first image with centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# data_loader = DataLoader(h5_filename='your_file.h5', tile_size=9)\n", + "tiles = data_loader.tile_image(data_loader.images[0])\n", + "\n", + "# Visualize the padded image with tiles\n", + "plt.figure(figsize=(10, 10))\n", + "plt.imshow(data_loader.images[0], cmap='gray')\n", + "tile_size = data_loader.tile_size\n", + "for i in range(1, data_loader.images[0].shape[0] // tile_size + 1):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + "for j in range(1, data_loader.images[0].shape[1] // tile_size + 1):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_training_data(train_dataset, image_index=0, tile_size=9, max_hits_per_tile=5):\n", + " \"\"\"\n", + " Visualizes an image and its tiles with midpoints from the training dataset.\n", + "\n", + " Parameters:\n", + " - train_dataset: tf.data.Dataset, the training dataset containing tiled images and centers.\n", + " - image_index: int, index of the image in the training dataset to visualize.\n", + " - tile_size: int, the size of each tile (e.g., 9x9).\n", + " - max_hits_per_tile: int, the maximum number of hits per tile.\n", + " \"\"\"\n", + " # Extract the specified image and its corresponding centers\n", + " images_list, centers_list = [], []\n", + " for images, centers in train_dataset:\n", + " images_list.append(images.numpy())\n", + " centers_list.append(centers.numpy())\n", + " tiled_images = np.concatenate(images_list, axis=0)\n", + " tiled_centers = np.concatenate(centers_list, axis=0)\n", + "\n", + " # Select the tiles and centers for the desired image index\n", + " num_tiles_per_row = int(np.sqrt(len(tiled_images) // (image_index + 1)))\n", + " start_index = image_index * num_tiles_per_row**2\n", + " end_index = start_index + num_tiles_per_row**2\n", + " tiled_images = tiled_images[start_index:end_index]\n", + " tiled_centers = tiled_centers[start_index:end_index]\n", + "\n", + " # Reconstruct the image from tiles\n", + " reconstructed_image = np.zeros((num_tiles_per_row * tile_size, num_tiles_per_row * tile_size))\n", + " tile_hits = []\n", + "\n", + " for idx, tile in enumerate(tiled_images):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile.squeeze()\n", + "\n", + " # Extract hits for this tile\n", + " hits = tiled_centers[idx].reshape(max_hits_per_tile, 2)\n", + " tile_hits.append((row, col, hits))\n", + "\n", + " # Plot the reconstructed image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(reconstructed_image, cmap='gray', extent=[0, reconstructed_image.shape[1], reconstructed_image.shape[0], 0])\n", + "\n", + " # Overlay tile grid\n", + " for i in range(1, num_tiles_per_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_per_row):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + "\n", + " # Plot midpoints in each tile\n", + " for row, col, hits in tile_hits:\n", + " for hit in hits:\n", + " x, y = hit\n", + " if x != 0 and y != 0: # Ignore padded hits\n", + " plt.plot(col + x * tile_size, row + y * tile_size, 'bo', markersize=5)\n", + "\n", + " plt.title(f\"Tiled Image {image_index} with Midpoints from Training Dataset\")\n", + " plt.xlabel(\"X-axis\")\n", + " plt.ylabel(\"Y-axis\")\n", + " plt.gca().invert_yaxis() # Match image coordinate system\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-20 16:07:02.873337: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" + ] + }, + { + "ename": "ValueError", + "evalue": "could not broadcast input array from shape (32,32) into shape (9,9)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mvisualize_training_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimage_index\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtile_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m9\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_hits_per_tile\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[13], line 33\u001b[0m, in \u001b[0;36mvisualize_training_data\u001b[0;34m(train_dataset, image_index, tile_size, max_hits_per_tile)\u001b[0m\n\u001b[1;32m 31\u001b[0m row \u001b[38;5;241m=\u001b[39m (idx \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m num_tiles_per_row) \u001b[38;5;241m*\u001b[39m tile_size\n\u001b[1;32m 32\u001b[0m col \u001b[38;5;241m=\u001b[39m (idx \u001b[38;5;241m%\u001b[39m num_tiles_per_row) \u001b[38;5;241m*\u001b[39m tile_size\n\u001b[0;32m---> 33\u001b[0m \u001b[43mreconstructed_image\u001b[49m\u001b[43m[\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m:\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mtile_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol\u001b[49m\u001b[43m:\u001b[49m\u001b[43mcol\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mtile_size\u001b[49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m tile\u001b[38;5;241m.\u001b[39msqueeze()\n\u001b[1;32m 35\u001b[0m \u001b[38;5;66;03m# Extract hits for this tile\u001b[39;00m\n\u001b[1;32m 36\u001b[0m hits \u001b[38;5;241m=\u001b[39m tiled_centers[idx]\u001b[38;5;241m.\u001b[39mreshape(max_hits_per_tile, \u001b[38;5;241m2\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: could not broadcast input array from shape (32,32) into shape (9,9)" + ] + } + ], + "source": [ + "visualize_training_data(train_dataset, image_index=2, tile_size=9, max_hits_per_tile=2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "d= DataLoader(file_path)\n", + "o =d.images\n", + "f = d.centers[:,:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10000, 50, 2)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(o[2], cmap='gray')\n", + "plt.scatter(f[2][:,0], f[2][:,1], color='red', marker='x', s=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(80000, 13, 1)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f[:,:,1:].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model definition" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "\n", + "def create_model(input_shape=(8, 8, 1), max_hits=2):\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + " \n", + " # First convolutional layer\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " \n", + " # First max pooling layer\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " \n", + " # Second convolutional layer\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " # x = layers.Conv2D(32, kernel_size=3, activation='relu')(x)\n", + " # x = layers.MaxPooling2D((2, 2))(x)\n", + " # Flatten the output\n", + " x = layers.Flatten()(x)\n", + " \n", + " # First dense layer\n", + " x = layers.Dense(128, activation='relu')(x)\n", + " \n", + " # Output layer: Predict x and y coordinates for each hit\n", + " outputs = layers.Dense(max_hits * 2,activation = 'sigmoid')(x)\n", + " \n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " \n", + " return model\n", + "\n", + "# Example usage:\n", + "# model = create_model()\n", + "# model.summary()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Custom Loss Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(a) Sorting Algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0), return_indices=False):\n", + "# reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + "# reference_point = tf.reshape(reference_point, (1, 1, 2))\n", + " \n", + "# midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + "# distances = tf.norm(midpoints - reference_point, axis=-1)\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " \n", + "# if return_indices:\n", + "# return sorted_midpoints, sorted_indices\n", + "# else:\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# reference_point = (0.0, 0.0)\n", + " \n", + "# # Sort y_true and get indices\n", + "# y_true_sorted, sorted_indices = sort_midpoints_by_distance(y_true, reference_point, return_indices=True)\n", + " \n", + "# # Reshape y_pred to match midpoints format\n", + "# y_pred = tf.reshape(y_pred, (-1, tf.shape(y_pred)[-1] // 2, 2))\n", + " \n", + "# # Sort y_pred using the indices from y_true\n", + "# y_pred_sorted = tf.gather(y_pred, sorted_indices, batch_dims=1)\n", + " \n", + "# # Compute the difference\n", + "# diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss\n", + "# return tf.reduce_mean(powered_diff)\n", + " \n", + "# return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss_debug(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0), return_indices=False):\n", + "# # Reshape reference_point to match the shape of midpoints for broadcasting\n", + "# reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + "# reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + "# # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + "# midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + "# # Calculate Euclidean distances from the reference point\n", + "# distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + "# # Get the sorted indices based on distances\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + "# # Gather the sorted midpoints\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " \n", + "# if return_indices:\n", + "# return sorted_midpoints, sorted_indices\n", + "# else:\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# # Define the reference point (e.g., top-left corner)\n", + "# reference_point = (0.0, 0.0)\n", + " \n", + "# # Sort y_true and get indices\n", + "# y_true_sorted, sorted_indices = sort_midpoints_by_distance(y_true, reference_point, return_indices=True)\n", + " \n", + "# # Reshape y_pred to match midpoints format\n", + "# y_pred = tf.reshape(y_pred, (-1, tf.shape(y_pred)[-1] // 2, 2))\n", + " \n", + "# # Sort y_pred using the indices from y_true\n", + "# y_pred_sorted = tf.gather(y_pred, sorted_indices, batch_dims=1)\n", + " \n", + "# # Create a mask to ignore ground truth values with (0,0)\n", + "# nonzero_mask = tf.reduce_any(tf.not_equal(y_true_sorted, [0.0, 0.0]), axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + "# def compute_loss():\n", + "# # Apply the mask to filter out invalid points\n", + "# y_true_masked = tf.boolean_mask(y_true_sorted, nonzero_mask)\n", + "# y_pred_masked = tf.boolean_mask(y_pred_sorted, nonzero_mask)\n", + "\n", + "# # Compute the difference\n", + "# diff = tf.abs(y_true_masked - y_pred_masked)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss\n", + "# return tf.reduce_mean(powered_diff)\n", + " \n", + "# def return_zero():\n", + "# return tf.constant(0.0, dtype=tf.float32)\n", + " \n", + "# # Use tf.cond to decide which branch to execute\n", + "# return tf.cond(tf.reduce_any(nonzero_mask), compute_loss, return_zero)\n", + " \n", + "# return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss_debug(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0), return_indices=False):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " \n", + " if return_indices:\n", + " return sorted_midpoints, sorted_indices\n", + " else:\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort y_true and get indices\n", + " y_true_sorted, sorted_indices = sort_midpoints_by_distance(y_true, reference_point, return_indices=True)\n", + " \n", + " # Reshape y_pred to match midpoints format\n", + " y_pred = tf.reshape(y_pred, (-1, tf.shape(y_pred)[-1] // 2, 2))\n", + " \n", + " # Sort y_pred using the indices from y_true\n", + " y_pred_sorted = tf.gather(y_pred, sorted_indices, batch_dims=1)\n", + " \n", + " # Create a mask to identify ground truth values with (0,0)\n", + " zero_mask = tf.reduce_all(tf.equal(y_true_sorted, [0.0, 0.0]), axis=-1) # Shape: (batch_size, num_midpoints)\n", + "\n", + " # Assign -2 to predictions corresponding to (0,0) ground truths\n", + " y_pred_adjusted = tf.where(\n", + " tf.expand_dims(zero_mask, axis=-1), # Expand dimensions for broadcasting\n", + " tf.constant([0.0, 0.0], dtype=y_pred_sorted.dtype), # Assign value\n", + " y_pred_sorted # Keep original predictions\n", + " )\n", + "\n", + " # Create a mask for valid points (non-zero ground truths)\n", + " nonzero_mask = tf.logical_not(zero_mask)\n", + "\n", + " def compute_loss():\n", + " # Apply the mask to filter out invalid points\n", + " y_true_masked = tf.boolean_mask(y_true_sorted, nonzero_mask)\n", + " y_pred_masked = tf.boolean_mask(y_pred_adjusted, nonzero_mask)\n", + "\n", + " # Compute the difference\n", + " diff = tf.abs(y_true_masked - y_pred_masked)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " def return_zero():\n", + " return tf.constant(0.0, dtype=tf.float32)\n", + " \n", + " # Use tf.cond to decide which branch to execute\n", + " return tf.cond(tf.reduce_any(nonzero_mask), compute_loss, return_zero)\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize model" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional_2\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional_2\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_3 (InputLayer)      │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_9 (Conv2D)               │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_3 (MaxPooling2D)  │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_10 (Conv2D)              │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_2 (Flatten)             │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_4 (Dense)                 │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_5 (Dense)                 │ (None, 4)              │           516 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_3 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_9 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_3 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_10 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_2 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_4 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_5 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m) │ \u001b[38;5;34m516\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 83,908 (327.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m83,908\u001b[0m (327.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "with strategy.scope():\n", + " model = create_model()\n", + " model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate = 0.001), loss=euclidean_sorted_custom_loss_debug(exponent=2.0))\n", + " \n", + " # Compile the model with the IoU-based loss\n", + " # model.compile(\n", + " # optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),\n", + " # loss=iou_sorted_custom_loss(box_size=1))\n", + " \n", + " model.summary()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Set up learning rate scheduler\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(\n", + " monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Train model" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:36:54.265841: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "2024-11-22 17:36:56.917996: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-22 17:36:56.939929: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1732315017.010013 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.012483 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.058073 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.058171 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.058588 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.058667 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.063312 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.063495 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.077072 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.077115 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.082501 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.082561 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.083692 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.083795 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.084216 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.084283 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.086991 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.087079 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.104211 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.104309 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.104720 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.104792 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.105206 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.105284 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.105696 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.105774 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.106179 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.106264 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.106705 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.106783 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.108349 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.108428 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.110025 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.110104 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.111720 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.111801 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.113614 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.113692 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.115423 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.115498 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.117327 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.117424 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.117934 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.118015 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.119431 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.119444 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.126859 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.126865 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.128549 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.128627 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.203680 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.203737 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.204191 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.204265 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.204595 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.204676 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.205155 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.205261 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.206076 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.206154 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.207478 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.207548 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.207893 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.207984 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.208294 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.208369 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.208701 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.208774 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.209109 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.209185 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.209512 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.209592 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.209934 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.210000 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.211174 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.211253 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.211892 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.211961 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.213426 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.213504 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.213840 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.213921 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.214272 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.214352 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.215501 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.215575 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.215956 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.216018 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.216378 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.216478 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.216818 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.216890 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.218150 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.218232 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.218575 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.218675 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.225536 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.225549 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.226007 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.226077 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.226463 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.226533 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.226942 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.227021 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.227497 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.227597 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.228049 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.228207 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.232791 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.232939 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.234837 1708354 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.234978 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 7/308\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2s\u001b[0m 9ms/step - loss: 0.0813 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1732315017.929476 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.932305 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.934784 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.936132 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.936218 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.936842 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.937119 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.937305 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.937520 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.937999 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.938084 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.938689 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.938779 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.939345 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.939430 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.939797 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.943732 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.943787 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.944297 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.944354 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.949040 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.949105 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.952477 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.952605 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.952914 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.953265 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.953373 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.953805 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.953875 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.954337 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.954416 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.954943 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.955009 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.955574 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.955665 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.956070 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.958170 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.958403 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.960029 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.960163 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.960399 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.960620 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.967560 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.967816 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.967960 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.968209 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.968477 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.968763 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.969896 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.970165 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.972081 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.972347 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.988554 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.990595 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.993614 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315017.995668 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.009742 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.010014 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.010478 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.010949 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.011192 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.011460 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.011622 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.011967 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.012902 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.012984 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.014251 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.014333 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.016025 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.016097 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.016726 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.016807 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.018478 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.018552 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.019256 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.019397 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.019653 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.019851 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.020045 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.020217 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.022349 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.022424 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.024057 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.024131 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.024534 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.024609 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.026085 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.026160 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.027821 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.027901 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.029673 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.029750 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.031820 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.031900 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.042678 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.042702 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.043125 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.043348 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.043519 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.043727 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.043958 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.044149 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.044396 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.044575 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.044816 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.044982 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.045258 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.045406 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.045679 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.046037 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.046192 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.046481 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.046696 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.046986 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.047962 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.048033 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.049193 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.049261 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.050013 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.050083 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.050790 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.050861 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.051999 1708353 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315018.052071 1708366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0264" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:37:00.792757: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-22 17:37:00.793077: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "W0000 00:00:1732315020.811862 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.812319 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.812601 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.812888 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.813244 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.813556 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.813878 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.814174 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.814460 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.814752 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.815067 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.815377 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.815693 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.816014 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.816329 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.816661 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.816977 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.817321 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.817672 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.818022 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.818368 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.818651 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.819026 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.819727 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.820071 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.840372 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.840862 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.841155 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.841318 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.841545 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.841809 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.842078 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.842235 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.842482 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.842653 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.842920 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.843083 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.843297 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.843709 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.843767 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.844138 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.844220 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.844558 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.844703 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.844944 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.845183 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.845388 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.845664 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.845791 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.846122 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.846263 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.846540 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.846694 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.846968 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.847199 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.847419 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.847605 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.847874 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.848068 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.848356 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.848491 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.848804 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.848935 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.849363 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.849440 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.849828 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.849910 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.850374 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.850402 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.850717 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.851243 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.851272 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.851659 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.851870 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.852281 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.852602 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.852939 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.853475 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.853978 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.855267 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.856395 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.870178 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.870476 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.870735 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.870815 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.871026 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.871298 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.871405 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.871619 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.871765 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.871979 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.872154 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.872395 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.872486 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.872759 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.873001 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.873117 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.873369 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.873482 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.873713 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.873871 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.874103 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.874226 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.874530 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.874595 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.874911 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.874971 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.875295 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.875348 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.875717 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.875773 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.876181 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.876305 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.876496 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.876698 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.876857 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.877081 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.877235 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.877447 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.877644 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.877859 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.878014 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.878255 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.878382 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.878576 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.878928 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.879012 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.879357 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.879482 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.879726 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.880205 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.880409 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.880754 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.881084 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.881357 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.881536 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.882043 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.882585 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.883850 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.884990 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.885747 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.886042 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.886663 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.886895 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.887166 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.887419 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.887660 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.888120 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.888625 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.888965 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.889219 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.889450 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.889684 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.890008 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.890247 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.897798 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.898129 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.898425 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.898715 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.898986 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.899267 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.899548 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.899831 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.900118 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.900418 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.900828 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.906700 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.906962 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.907246 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.907542 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.907763 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.908021 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.908231 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.908486 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.908791 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.908879 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.909121 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.909452 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.909719 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.909904 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.910190 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.910483 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.910940 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.911024 1708341 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.911270 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.911752 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.912040 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.912330 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.912620 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.912900 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.913195 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.913484 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.913787 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.914088 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.914397 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.914780 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.915090 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.915452 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.915928 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.916477 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.917190 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.918332 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.926968 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.927336 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.928002 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.928316 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.928631 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.928906 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.929193 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.929666 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.930132 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.930477 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.930747 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.931010 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.931264 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.931640 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.931920 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.937884 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.938202 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.938491 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.938781 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.939051 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.939329 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.939613 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.939896 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.940182 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.940482 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.940889 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.941800 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.942065 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.942588 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.942995 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.943409 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.943674 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.944430 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315020.945626 1708360 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.378479 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.378929 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.379266 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.381153 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.381615 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.382285 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.382371 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.383009 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.383104 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.383479 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.383604 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.384042 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.384120 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.384549 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.384737 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.385360 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.385385 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.385875 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.385984 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.386314 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.386498 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.386806 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.387012 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.387322 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.387510 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.388007 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.388100 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.388412 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.388719 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.388915 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.389169 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.389557 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.389687 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.390350 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.390370 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.390891 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.391083 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.391569 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.392839 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.393687 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.393759 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.394252 1708333 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.394572 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.395165 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 13ms/step - loss: 0.0264 - val_loss: 0.0048 - learning_rate: 0.0010\n", + "Epoch 2/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:37:01.862576: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "W0000 00:00:1732315021.876705 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.877177 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.877532 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.877873 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.878204 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.878521 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.878658 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.879016 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.879226 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.879789 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.879841 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.880224 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.880436 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.880728 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.880937 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.881236 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.881450 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.881704 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.881925 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.882466 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.882529 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.883093 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.883212 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.883718 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.883782 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.884306 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.884607 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.884759 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.885380 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.885456 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.885979 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.886191 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.886447 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.886807 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.886952 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.887424 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.888011 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.888529 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.888746 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.889508 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.889981 1708358 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.890312 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.891087 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732315021.891554 1708367 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m307/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0043" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:37:04.837981: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0043 - val_loss: 0.0042 - learning_rate: 0.0010\n", + "Epoch 3/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0039 - val_loss: 0.0041 - learning_rate: 0.0010\n", + "Epoch 4/100\n", + "\u001b[1m 1/308\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m46s\u001b[0m 152ms/step - loss: 0.0048" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:37:09.175493: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0038 - val_loss: 0.0040 - learning_rate: 0.0010\n", + "Epoch 5/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0037 - val_loss: 0.0040 - learning_rate: 0.0010\n", + "Epoch 6/100\n", + "\u001b[1m307/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0037" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:37:19.594151: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0037 - val_loss: 0.0040 - learning_rate: 0.0010\n", + "Epoch 7/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0037 - val_loss: 0.0040 - learning_rate: 0.0010\n", + "Epoch 8/100\n", + "\u001b[1m306/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0036" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:37:26.876708: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0036 - val_loss: 0.0040 - learning_rate: 0.0010\n", + "Epoch 9/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0036 - val_loss: 0.0041 - learning_rate: 0.0010\n", + "Epoch 10/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0036 - val_loss: 0.0041 - learning_rate: 0.0010\n", + "Epoch 11/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0035 - val_loss: 0.0041 - learning_rate: 0.0010\n", + "Epoch 12/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:37:38.623521: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0035 - val_loss: 0.0041 - learning_rate: 0.0010\n", + "Epoch 13/100\n", + "\u001b[1m306/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0035\n", + "Epoch 13: ReduceLROnPlateau reducing learning rate to 0.0009000000427477062.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0035 - val_loss: 0.0042 - learning_rate: 0.0010\n", + "Epoch 14/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0034 - val_loss: 0.0042 - learning_rate: 9.0000e-04\n", + "Epoch 15/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0034 - val_loss: 0.0042 - learning_rate: 9.0000e-04\n", + "Epoch 16/100\n", + "\u001b[1m306/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0034" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:37:57.004719: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0034 - val_loss: 0.0042 - learning_rate: 9.0000e-04\n", + "Epoch 17/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0033 - val_loss: 0.0043 - learning_rate: 9.0000e-04\n", + "Epoch 18/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0033 - val_loss: 0.0043 - learning_rate: 9.0000e-04\n", + "Epoch 19/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0032 - val_loss: 0.0043 - learning_rate: 9.0000e-04\n", + "Epoch 20/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0032 - val_loss: 0.0044 - learning_rate: 9.0000e-04\n", + "Epoch 21/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0032 - val_loss: 0.0044 - learning_rate: 9.0000e-04\n", + "Epoch 22/100\n", + "\u001b[1m307/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0031" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:38:19.438826: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0031 - val_loss: 0.0044 - learning_rate: 9.0000e-04\n", + "Epoch 23/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0031\n", + "Epoch 23: ReduceLROnPlateau reducing learning rate to 0.0008100000384729356.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0031 - val_loss: 0.0045 - learning_rate: 9.0000e-04\n", + "Epoch 24/100\n", + "\u001b[1m306/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0030" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:38:27.087513: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0030 - val_loss: 0.0045 - learning_rate: 8.1000e-04\n", + "Epoch 25/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0030 - val_loss: 0.0046 - learning_rate: 8.1000e-04\n", + "Epoch 26/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0029 - val_loss: 0.0046 - learning_rate: 8.1000e-04\n", + "Epoch 27/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0029 - val_loss: 0.0047 - learning_rate: 8.1000e-04\n", + "Epoch 28/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0029 - val_loss: 0.0047 - learning_rate: 8.1000e-04\n", + "Epoch 29/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0028 - val_loss: 0.0047 - learning_rate: 8.1000e-04\n", + "Epoch 30/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0028 - val_loss: 0.0048 - learning_rate: 8.1000e-04\n", + "Epoch 31/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0028 - val_loss: 0.0048 - learning_rate: 8.1000e-04\n", + "Epoch 32/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0027 - val_loss: 0.0048 - learning_rate: 8.1000e-04\n", + "Epoch 33/100\n", + "\u001b[1m 14/308\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2s\u001b[0m 9ms/step - loss: 0.0032 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:38:57.226808: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m306/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0027\n", + "Epoch 33: ReduceLROnPlateau reducing learning rate to 0.0007290000503417104.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0027 - val_loss: 0.0049 - learning_rate: 8.1000e-04\n", + "Epoch 34/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0027 - val_loss: 0.0048 - learning_rate: 7.2900e-04\n", + "Epoch 35/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0026 - val_loss: 0.0049 - learning_rate: 7.2900e-04\n", + "Epoch 36/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0026 - val_loss: 0.0049 - learning_rate: 7.2900e-04\n", + "Epoch 37/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0026 - val_loss: 0.0049 - learning_rate: 7.2900e-04\n", + "Epoch 38/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0026 - val_loss: 0.0049 - learning_rate: 7.2900e-04\n", + "Epoch 39/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0026 - val_loss: 0.0050 - learning_rate: 7.2900e-04\n", + "Epoch 40/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0025 - val_loss: 0.0050 - learning_rate: 7.2900e-04\n", + "Epoch 41/100\n", + "\u001b[1m303/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0025" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:39:30.072837: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0025 - val_loss: 0.0050 - learning_rate: 7.2900e-04\n", + "Epoch 42/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0025 - val_loss: 0.0051 - learning_rate: 7.2900e-04\n", + "Epoch 43/100\n", + "\u001b[1m307/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0025\n", + "Epoch 43: ReduceLROnPlateau reducing learning rate to 0.0006561000715009868.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0025 - val_loss: 0.0051 - learning_rate: 7.2900e-04\n", + "Epoch 44/100\n", + "\u001b[1m 1/308\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m44s\u001b[0m 144ms/step - loss: 0.0042" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:39:37.963134: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0025 - val_loss: 0.0051 - learning_rate: 6.5610e-04\n", + "Epoch 45/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0025 - val_loss: 0.0051 - learning_rate: 6.5610e-04\n", + "Epoch 46/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0024 - val_loss: 0.0051 - learning_rate: 6.5610e-04\n", + "Epoch 47/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0024 - val_loss: 0.0052 - learning_rate: 6.5610e-04\n", + "Epoch 48/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0024 - val_loss: 0.0052 - learning_rate: 6.5610e-04\n", + "Epoch 49/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0024 - val_loss: 0.0052 - learning_rate: 6.5610e-04\n", + "Epoch 50/100\n", + "\u001b[1m 15/308\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2s\u001b[0m 7ms/step - loss: 0.0027 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:40:00.192334: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0024 - val_loss: 0.0053 - learning_rate: 6.5610e-04\n", + "Epoch 51/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0024 - val_loss: 0.0053 - learning_rate: 6.5610e-04\n", + "Epoch 52/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0053 - learning_rate: 6.5610e-04\n", + "Epoch 53/100\n", + "\u001b[1m305/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0023\n", + "Epoch 53: ReduceLROnPlateau reducing learning rate to 0.0005904900433961303.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0053 - learning_rate: 6.5610e-04\n", + "Epoch 54/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0054 - learning_rate: 5.9049e-04\n", + "Epoch 55/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0054 - learning_rate: 5.9049e-04\n", + "Epoch 56/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0054 - learning_rate: 5.9049e-04\n", + "Epoch 57/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0054 - learning_rate: 5.9049e-04\n", + "Epoch 58/100\n", + "\u001b[1m303/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0023" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:40:31.570257: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0055 - learning_rate: 5.9049e-04\n", + "Epoch 59/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0055 - learning_rate: 5.9049e-04\n", + "Epoch 60/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0055 - learning_rate: 5.9049e-04\n", + "Epoch 61/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0055 - learning_rate: 5.9049e-04\n", + "Epoch 62/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0023 - val_loss: 0.0055 - learning_rate: 5.9049e-04\n", + "Epoch 63/100\n", + "\u001b[1m305/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 0.0022\n", + "Epoch 63: ReduceLROnPlateau reducing learning rate to 0.0005314410547725857.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 10ms/step - loss: 0.0022 - val_loss: 0.0056 - learning_rate: 5.9049e-04\n", + "Epoch 64/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0056 - learning_rate: 5.3144e-04\n", + "Epoch 65/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0056 - learning_rate: 5.3144e-04\n", + "Epoch 66/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0056 - learning_rate: 5.3144e-04\n", + "Epoch 67/100\n", + "\u001b[1m305/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0022" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:41:03.281972: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0056 - learning_rate: 5.3144e-04\n", + "Epoch 68/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0056 - learning_rate: 5.3144e-04\n", + "Epoch 69/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0056 - learning_rate: 5.3144e-04\n", + "Epoch 70/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0057 - learning_rate: 5.3144e-04\n", + "Epoch 71/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0057 - learning_rate: 5.3144e-04\n", + "Epoch 72/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0022 - val_loss: 0.0057 - learning_rate: 5.3144e-04\n", + "Epoch 73/100\n", + "\u001b[1m307/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0021\n", + "Epoch 73: ReduceLROnPlateau reducing learning rate to 0.00047829695977270604.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 5.3144e-04\n", + "Epoch 74/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 75/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 76/100\n", + "\u001b[1m307/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0021" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:41:35.568413: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 77/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 78/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 79/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 80/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 81/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 82/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 83/100\n", + "\u001b[1m305/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0021\n", + "Epoch 83: ReduceLROnPlateau reducing learning rate to 0.0004304672533180565.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.7830e-04\n", + "Epoch 84/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.3047e-04\n", + "Epoch 85/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0021" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:42:07.859761: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0057 - learning_rate: 4.3047e-04\n", + "Epoch 86/100\n", + "\u001b[1m306/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0021" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:42:11.183668: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 10ms/step - loss: 0.0021 - val_loss: 0.0058 - learning_rate: 4.3047e-04\n", + "Epoch 87/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0058 - learning_rate: 4.3047e-04\n", + "Epoch 88/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0021 - val_loss: 0.0058 - learning_rate: 4.3047e-04\n", + "Epoch 89/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 4.3047e-04\n", + "Epoch 90/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 4.3047e-04\n", + "Epoch 91/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 12ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 4.3047e-04\n", + "Epoch 92/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 4.3047e-04\n", + "Epoch 93/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0020\n", + "Epoch 93: ReduceLROnPlateau reducing learning rate to 0.00038742052274756136.\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 4.3047e-04\n", + "Epoch 94/100\n", + "\u001b[1m303/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - loss: 0.0020" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:42:40.557267: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 3.8742e-04\n", + "Epoch 95/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 3.8742e-04\n", + "Epoch 96/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 3.8742e-04\n", + "Epoch 97/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 3.8742e-04\n", + "Epoch 98/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 3.8742e-04\n", + "Epoch 99/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 3.8742e-04\n", + "Epoch 100/100\n", + "\u001b[1m308/308\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 11ms/step - loss: 0.0020 - val_loss: 0.0058 - learning_rate: 3.8742e-04\n" + ] + } + ], + "source": [ + "\n", + "# Train the model\n", + "history = model.fit(\n", + " train_dataset, # Dataset prepared in your previous code\n", + " validation_data=val_dataset,\n", + " epochs=100,\n", + " batch_size=100,callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training Results" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# loaded_model = tf.keras.models.load_model('/home/da886/Electron Counting Tiling approach/Trained weights/200KFixed_100_256by256_First150K_95indexNoNoise.keras')\n", + "# model.save('/home/da886/Electron Counting Tiling approach/Trained weights/200KFixed_100_256by256_First150K_loss using indices_95indexNoNoise.keras')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Post Training Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def predict_and_visualize(model, data_loader, dataset, img_idx, tile_size=8, max_hits_per_tile=2, threshold=2):\n", + " \"\"\"\n", + " Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access image and tile information.\n", + " - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + " \"\"\"\n", + " # Calculate the grid size based on the image and tile size\n", + " grid_size = 256 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + " # Initialize variables to store the cumulative number of images processed\n", + " cumulative_images = 0\n", + "\n", + " # Iterate over the dataset to find the batch containing the desired image index\n", + " for batch_images, batch_true_centers in dataset:\n", + " # Calculate the number of images in the current batch\n", + " num_tiles_in_batch = batch_images.shape[0]\n", + " num_images_in_batch = num_tiles_in_batch // (grid_size ** 2)\n", + "\n", + " # Check if the desired image is in the current batch\n", + " if cumulative_images + num_images_in_batch > img_idx:\n", + " # Calculate the index of the image within the batch\n", + " batch_img_idx = img_idx - cumulative_images\n", + "\n", + " # Extract the tiles and true centers for the desired image\n", + " start_idx = batch_img_idx * grid_size**2\n", + " end_idx = (batch_img_idx + 1) * grid_size**2\n", + " image_tiles = batch_images[start_idx:end_idx]\n", + " true_centers_tiles = batch_true_centers[start_idx:end_idx]\n", + " break\n", + "\n", + " cumulative_images += num_images_in_batch\n", + " else:\n", + " # If we exit the loop normally, the image index was out of range\n", + " raise IndexError(f\"Image index {img_idx} is out of range.\")\n", + "\n", + " # Make predictions on the tiles of the chosen image\n", + " predictions = model.predict(image_tiles)\n", + "\n", + " # Reshape predictions for visualization\n", + " predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + " ) # 8x8 grid for a 64x64 image\n", + "\n", + " # Visualize the original image with both true and filtered predicted hit centers\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(15, 15))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + " # Overlay the tile boundaries\n", + " for i in range(1, grid_size):\n", + " # Horizontal lines\n", + " ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " # Vertical lines\n", + " ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true and filtered predicted centers on the reconstructed image\n", + " for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " # Plot true centers in green\n", + " true_tile_centers = true_centers_tiles[tile_idx].numpy().reshape(-1, 2)\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='green', marker='x', s=10,\n", + " label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot filtered predicted centers in red\n", + " predicted_tile_centers = predicted_centers[tile_idx]\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0)and (x >= threshold / tile_size or y >= threshold / tile_size):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='red', marker='o', s=10,\n", + " label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t = np.random.randint(0, 1000)\n", + "predict_and_visualize(model, data_loader, train_dataset, img_idx=t)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 32, 32, 1)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 30, 30, 128)    │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 15, 15, 128)    │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 13, 13, 64)     │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 11, 11, 32)     │        18,464 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 3872)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │       495,744 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 16)             │         2,064 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m30\u001b[0m, \u001b[38;5;34m30\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m15\u001b[0m, \u001b[38;5;34m15\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m11\u001b[0m, \u001b[38;5;34m11\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m18,464\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3872\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m495,744\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m2,064\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 1,774,034 (6.77 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m1,774,034\u001b[0m (6.77 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 591,344 (2.26 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m591,344\u001b[0m (2.26 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Optimizer params: 1,182,690 (4.51 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m1,182,690\u001b[0m (4.51 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "loaded_model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss_debug(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0), return_indices=False):\n", + "# # Reshape reference_point to match the shape of midpoints for broadcasting\n", + "# reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + "# reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + "# # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + "# midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + "# # Calculate Euclidean distances from the reference point\n", + "# distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + "# # Get the sorted indices based on distances\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + "# # Gather the sorted midpoints\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " \n", + "# if return_indices:\n", + "# return sorted_midpoints, sorted_indices\n", + "# else:\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# # Define the reference point (e.g., top-left corner)\n", + "# reference_point = (0.0, 0.0)\n", + " \n", + "# # Sort y_true and get indices\n", + "# y_true_sorted, sorted_indices = sort_midpoints_by_distance(y_true, reference_point, return_indices=True)\n", + " \n", + "# # Reshape y_pred to match midpoints format\n", + "# y_pred = tf.reshape(y_pred, (-1, tf.shape(y_pred)[-1] // 2, 2))\n", + " \n", + "# # Sort y_pred using the indices from y_true\n", + "# y_pred_sorted = tf.gather(y_pred, sorted_indices, batch_dims=1)\n", + "# # Create a mask to ignore ground truth values with (0,0)\n", + "# nonzero_mask = tf.reduce_any(tf.not_equal(y_true_sorted, [0.0, 0.0]), axis=-1) # Shape: (batch_size, num_midpoints)\n", + "\n", + "# if np.max(nonzero_mask) == True:\n", + " \n", + "# # Apply the mask to filter out invalid points\n", + "# y_true_masked = tf.boolean_mask(y_true_sorted, nonzero_mask)\n", + "# y_pred_masked = tf.boolean_mask(y_pred_sorted, nonzero_mask)\n", + "\n", + "# # Compute the difference\n", + "# diff = tf.abs(y_true_masked - y_pred_masked)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss\n", + "# return tf.reduce_mean(powered_diff).numpy()\n", + "# else:\n", + "# return 0.0\n", + " \n", + "# return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss_debug2(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0), return_indices=False):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " \n", + " if return_indices:\n", + " return sorted_midpoints, sorted_indices\n", + " else:\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort y_true and get indices\n", + " y_true_sorted, sorted_indices = sort_midpoints_by_distance(y_true, reference_point, return_indices=True)\n", + " \n", + " # Reshape y_pred to match midpoints format\n", + " y_pred = tf.reshape(y_pred, (-1, tf.shape(y_pred)[-1] // 2, 2))\n", + " \n", + " # Sort y_pred using the indices from y_true\n", + " y_pred_sorted = tf.gather(y_pred, sorted_indices, batch_dims=1)\n", + " \n", + " # Create a mask to ignore ground truth values with (0,0)\n", + " nonzero_mask = tf.reduce_any(tf.not_equal(y_true_sorted, [0,0]), axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Check if any valid points exist\n", + " if tf.reduce_any(nonzero_mask): # This replaces np.max(nonzero_mask) == True\n", + " # Apply the mask to filter out invalid points\n", + " y_true_masked = tf.boolean_mask(y_true_sorted, nonzero_mask)\n", + " y_pred_masked = tf.boolean_mask(y_pred_sorted, nonzero_mask)\n", + "\n", + " # Compute the difference\n", + " diff = tf.abs(y_true_masked - y_pred_masked)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff).numpy()\n", + " else:\n", + " return 0.0\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss_debug(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0), return_indices=False):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " \n", + " if return_indices:\n", + " return sorted_midpoints, sorted_indices\n", + " else:\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort y_true and get indices\n", + " y_true_sorted, sorted_indices = sort_midpoints_by_distance(y_true, reference_point, return_indices=True)\n", + " \n", + " # Reshape y_pred to match midpoints format\n", + " y_pred = tf.reshape(y_pred, (-1, tf.shape(y_pred)[-1] // 2, 2))\n", + " \n", + " # Sort y_pred using the indices from y_true\n", + " y_pred_sorted = tf.gather(y_pred, sorted_indices, batch_dims=1)\n", + " \n", + " # Create a mask to identify ground truth values with (0,0)\n", + " zero_mask = tf.reduce_all(tf.equal(y_true_sorted, [0.0, 0.0]), axis=-1) # Shape: (batch_size, num_midpoints)\n", + "\n", + " # Assign -2 to predictions corresponding to (0,0) ground truths\n", + " y_pred_adjusted = tf.where(\n", + " tf.expand_dims(zero_mask, axis=-1), # Expand dimensions for broadcasting\n", + " tf.constant([-4, -4], dtype=y_pred_sorted.dtype), # Assign value\n", + " y_pred_sorted # Keep original predictions\n", + " )\n", + "\n", + " # Create a mask for valid points (non-zero ground truths)\n", + " nonzero_mask = tf.logical_not(zero_mask)\n", + "\n", + " def compute_loss():\n", + " # Apply the mask to filter out invalid points\n", + " y_true_masked = tf.boolean_mask(y_true_sorted, nonzero_mask)\n", + " y_pred_masked = tf.boolean_mask(y_pred_adjusted, nonzero_mask)\n", + "\n", + " # Compute the difference\n", + " diff = tf.abs(y_true_masked - y_pred_masked)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " def return_zero():\n", + " return tf.constant(0.0, dtype=tf.float32)\n", + " \n", + " # Use tf.cond to decide which branch to execute\n", + " return tf.cond(tf.reduce_any(nonzero_mask), compute_loss, return_zero)\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss value: tf.Tensor(8.0425, shape=(), dtype=float32)\n" + ] + } + ], + "source": [ + "loss_fn = euclidean_sorted_custom_loss_debug(exponent=2)\n", + "\n", + "# Example data\n", + "y_true = tf.constant([[1.0, 1.0, 0.0, 0.0, 3.0, 3.0]])\n", + "# y_true = tf.constant([[0, 0, 0.0, 0.0, 0, 0]])\n", + "y_pred = tf.constant([[5, 5, 2.1, 2.1, 3.1, 3.4]])\n", + "# y_pred_2 =tf.constant([[1.1, 1.1, 0, 0, 3.1, 3.4]])\n", + "\n", + "# y_true = tf.constant([[1.0, 1.0]])\n", + "# y_pred = tf.constant([[1.1, 1.1]])\n", + "\n", + "loss_value = loss_fn(y_true, y_pred)\n", + "print(\"Loss value:\", loss_value)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "y_pred = " + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dtype('float32')" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_value.dtype" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.010000004" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf.keras.losses.MeanSquaredError()(y_true, y_pred).numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(np.array([False,False,True])) == True" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "\n", + "# TensorFlow equivalent of np.max([False, False, True])\n", + "tensor = tf.constant([False, False, True], dtype=tf.bool)\n", + "result = tf.reduce_max(tf.cast(tensor, tf.int32)) # Convert boolean to int before reducing\n", + "print(result.numpy()) # Output: 1 (equivalent to True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for -: 'list' and 'list'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[24], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m Loss \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mreduce_mean([\u001b[43m[\u001b[49m\u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1.0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1.1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m^\u001b[39m\u001b[38;5;241m2\u001b[39m,\n\u001b[1;32m 2\u001b[0m [\u001b[38;5;241m3.0\u001b[39m, \u001b[38;5;241m3.0\u001b[39m] \u001b[38;5;241m-\u001b[39m [\u001b[38;5;241m3.1\u001b[39m, \u001b[38;5;241m3.1\u001b[39m]\u001b[38;5;241m^\u001b[39m\u001b[38;5;241m2\u001b[39m,\n\u001b[1;32m 3\u001b[0m [\u001b[38;5;241m5.0\u001b[39m, \u001b[38;5;241m5.0\u001b[39m] \u001b[38;5;241m-\u001b[39m [\u001b[38;5;241m5.1\u001b[39m, \u001b[38;5;241m5.1\u001b[39m]\u001b[38;5;241m^\u001b[39m\u001b[38;5;241m2\u001b[39m,\n\u001b[1;32m 4\u001b[0m [\u001b[38;5;241m6.0\u001b[39m, \u001b[38;5;241m6.0\u001b[39m] \u001b[38;5;241m-\u001b[39m [\u001b[38;5;241m6.1\u001b[39m, \u001b[38;5;241m6.1\u001b[39m]\u001b[38;5;241m^\u001b[39m\u001b[38;5;241m2\u001b[39m\n\u001b[1;32m 5\u001b[0m ])\n", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'list' and 'list'" + ] + } + ], + "source": [ + "Loss = tf.reduce_mean([[1.0, 1.0] - [1.1, 1.1]^2,\n", + " [3.0, 3.0] - [3.1, 3.1]^2,\n", + " [5.0, 5.0] - [5.1, 5.1]^2,\n", + " [6.0, 6.0] - [6.1, 6.1]^2\n", + "])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def predict_and_visualize(model, data_loader, dataset, img_idx, tile_size=32, max_hits_per_tile=8, threshold=0):\n", + " \"\"\"\n", + " Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + " Additionally, logs and returns the actual plotted values for inspection.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access image and tile information.\n", + " - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + "\n", + " Returns:\n", + " - reconstructed_image: The reconstructed image for the selected index.\n", + " - all_true_centers: List of true centers plotted on the image.\n", + " - all_predicted_centers: List of predicted centers plotted on the image.\n", + " \"\"\"\n", + " grid_size = 256 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + " # Initialize variables to store the cumulative number of images processed\n", + " cumulative_images = 0\n", + "\n", + " # Iterate over the dataset to find the batch containing the desired image index\n", + " for batch_images, batch_true_centers in dataset:\n", + " num_tiles_in_batch = batch_images.shape[0]\n", + " num_images_in_batch = num_tiles_in_batch // (grid_size ** 2)\n", + "\n", + " if cumulative_images + num_images_in_batch > img_idx:\n", + " batch_img_idx = img_idx - cumulative_images\n", + " start_idx = batch_img_idx * grid_size**2\n", + " end_idx = (batch_img_idx + 1) * grid_size**2\n", + " image_tiles = batch_images[start_idx:end_idx]\n", + " true_centers_tiles = batch_true_centers[start_idx:end_idx]\n", + " break\n", + "\n", + " cumulative_images += num_images_in_batch\n", + " else:\n", + " raise IndexError(f\"Image index {img_idx} is out of range.\")\n", + "\n", + " predictions = model.predict(image_tiles)\n", + " predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2)\n", + "\n", + " reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + " )\n", + "\n", + " all_true_centers = [] # Collect all true centers\n", + " all_predicted_centers = [] # Collect all predicted centers\n", + "\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(15, 15))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + " for i in range(1, grid_size):\n", + " ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " for tile_idx in range(grid_size**2):\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " true_tile_centers = true_centers_tiles[tile_idx].numpy().reshape(-1, 2)\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0):\n", + " all_true_centers.append((col_offset + x * tile_size, row_offset + y * tile_size))\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='green', marker='x', s=10,\n", + " label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " predicted_tile_centers = predicted_centers[tile_idx]\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0): \n", + " all_predicted_centers.append((col_offset + x * tile_size, row_offset + y * tile_size))\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='red', marker='o', s=10,\n", + " label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + " plt.show()\n", + "\n", + " return reconstructed_image, all_true_centers, all_predicted_centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 2ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 14:55:56.557682: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True Hit Centers: [(28.0, 28.0), (15.0, 24.0), (1.0, 11.0), (36.0, 30.0), (76.0, 24.0), (95.0, 1.0), (121.0, 6.0), (144.0, 29.0), (181.0, 28.0), (183.0, 14.0), (209.0, 17.0), (194.0, 31.0), (253.0, 9.0), (21.0, 59.0), (12.0, 48.0), (22.0, 46.0), (37.0, 47.0), (129.0, 37.0), (152.0, 32.0), (190.0, 40.0), (181.0, 60.0), (199.0, 38.0), (201.0, 63.0), (223.0, 53.0), (235.0, 63.0), (239.0, 43.0), (237.0, 60.0), (5.0, 94.0), (12.0, 84.0), (23.0, 81.0), (58.0, 91.0), (101.0, 67.0), (99.0, 74.0), (114.0, 73.0), (96.0, 76.0), (153.0, 79.0), (163.0, 84.0), (174.0, 70.0), (177.0, 91.0), (204.0, 88.0), (223.0, 70.0), (233.0, 75.0), (90.0, 115.0), (89.0, 121.0), (87.0, 113.0), (115.0, 120.0), (112.0, 122.0), (144.0, 116.0), (157.0, 118.0), (151.0, 116.0), (186.0, 112.0), (218.0, 123.0), (193.0, 127.0), (235.0, 103.0), (16.0, 132.0), (21.0, 149.0), (38.0, 128.0), (68.0, 142.0), (71.0, 157.0), (92.0, 155.0), (149.0, 139.0), (136.0, 152.0), (138.0, 132.0), (188.0, 158.0), (178.0, 156.0), (201.0, 139.0), (201.0, 159.0), (62.0, 166.0), (52.0, 169.0), (73.0, 171.0), (78.0, 184.0), (101.0, 175.0), (127.0, 160.0), (143.0, 176.0), (167.0, 160.0), (13.0, 193.0), (1.0, 203.0), (49.0, 223.0), (124.0, 211.0), (115.0, 193.0), (128.0, 196.0), (131.0, 213.0), (146.0, 208.0), (182.0, 192.0), (212.0, 201.0), (216.0, 211.0), (233.0, 196.0), (241.0, 192.0), (13.0, 225.0), (8.0, 227.0), (19.0, 244.0), (82.0, 244.0), (68.0, 228.0), (106.0, 255.0), (144.0, 228.0), (153.0, 250.0), (138.0, 253.0), (146.0, 239.0), (226.0, 229.0), (254.0, 236.0)]\n", + "Predicted Hit Centers: [(18.172513961791992, 28.88302230834961), (14.303359985351562, 17.915340423583984), (6.88498592376709, 11.169920921325684), (13.2353515625, 24.728288650512695), (31.012760162353516, 21.875364303588867), (13.626761436462402, 27.410703659057617), (8.625152587890625, 20.09687042236328), (43.455467224121094, 3.521744728088379), (36.69009733200073, 30.943683624267578), (40.3771276473999, 27.733898162841797), (42.26360893249512, 20.11302375793457), (51.087961196899414, 17.689027786254883), (27.12729263305664, 6.957557201385498), (27.754786491394043, 27.88056755065918), (35.26778817176819, 16.556922912597656), (58.117902755737305, 3.0836024284362793), (88.10338592529297, 6.063652992248535), (81.2297477722168, 23.246463775634766), (80.33990859985352, 15.015663146972656), (78.37281703948975, 20.88801383972168), (75.98408317565918, 21.493967056274414), (75.18474197387695, 8.850672721862793), (83.29624938964844, 16.954477310180664), (84.54402351379395, 10.162192344665527), (123.0800895690918, 5.993537425994873), (121.08721542358398, 3.9565820693969727), (108.5529375076294, 23.573766708374023), (114.89506721496582, 23.531021118164062), (106.19825172424316, 11.950517654418945), (123.6971263885498, 17.772266387939453), (112.30805015563965, 10.59819221496582), (134.91896057128906, -5.7764153480529785), (145.17188835144043, 28.109821319580078), (139.79295253753662, 23.708724975585938), (140.626145362854, 24.204833984375), (140.33285808563232, 12.9613618850708), (132.32954454421997, 19.509653091430664), (125.87476348876953, 20.02557945251465), (118.43879222869873, 21.445154190063477), (164.3731346130371, 10.82632064819336), (185.2580108642578, 21.262426376342773), (183.1010684967041, 23.255464553833008), (176.6515121459961, 25.765668869018555), (171.22424030303955, 3.5897433757781982), (180.32695770263672, -1.7540615797042847), (186.9112377166748, 15.361376762390137), (173.9083194732666, 0.00616532564163208), (212.6907501220703, 10.172741889953613), (199.74560546875, 33.19182205200195), (208.4246883392334, 17.297090530395508), (203.92590236663818, 15.962956428527832), (219.90078163146973, 23.17059898376465), (195.12156915664673, 13.111610412597656), (194.0780324935913, 13.917851448059082), (200.6946029663086, 11.019767761230469), (223.1236400604248, 2.4232664108276367), (252.75408363342285, 8.331682205200195), (246.50635147094727, 12.212082862854004), (235.21554279327393, 20.129989624023438), (252.42190170288086, 18.09840965270996), (238.84687900543213, 7.724736213684082), (244.74889755249023, 4.850569248199463), (241.09409141540527, 19.747116088867188), (263.57629013061523, 1.510390281677246), (9.374114036560059, 47.30976486206055), (23.860280990600586, 53.29917907714844), (23.434877395629883, 55.3658332824707), (14.200733184814453, 32.258848965168), (17.200180053710938, 23.99833393096924), (16.236143112182617, 53.64609909057617), (7.153257369995117, 58.63801383972168), (19.562467575073242, 43.60063648223877), (37.857712268829346, 46.33271503448486), (45.12369632720947, 54.32465362548828), (42.91117286682129, 48.85661697387695), (45.83984661102295, 40.909156799316406), (39.98483657836914, 45.731666564941406), (28.710845947265625, 49.26409339904785), (34.91572308540344, 49.20028114318848), (43.422139167785645, 48.16120529174805), (80.83090591430664, 48.54524612426758), (80.58893966674805, 51.42690086364746), (77.46323108673096, 56.80885314941406), (85.76003456115723, 44.7457971572876), (72.40695762634277, 40.80841255187988), (69.02729988098145, 51.165788650512695), (73.52750205993652, 54.31164360046387), (94.35803031921387, 32.80630683898926), (112.83090591430664, 48.54524612426758), (112.58893966674805, 51.42690086364746), (109.46323108673096, 56.80885314941406), (117.76003456115723, 44.7457971572876), (104.40695762634277, 40.80841255187988), (101.02729988098145, 51.165788650512695), (105.52750205993652, 54.31164360046387), (126.35803031921387, 32.80630683898926), (143.72072219848633, 36.2058629989624), (135.83037185668945, 36.117677211761475), (143.73338222503662, 43.88024425506592), (139.1454153060913, 42.383498191833496), (141.90508365631104, 28.431360721588135), (145.35374641418457, 43.656413078308105), (136.8394317626953, 46.6425142288208), (139.5767946243286, 41.529300689697266), (187.13568496704102, 40.57391548156738), (184.54120635986328, 61.21513366699219), (170.13879585266113, 49.58246040344238), (187.6573829650879, 41.64534091949463), (177.50767135620117, 45.38375186920166), (171.59654140472412, 30.318573236465454), (175.36221981048584, 17.894031524658203), (203.520751953125, 35.07219409942627), (212.8732204437256, 50.83623695373535), (203.2974100112915, 55.19792366027832), (206.34582042694092, 49.440961837768555), (195.71363925933838, 51.3078727722168), (218.65288734436035, 57.89525032043457), (191.2300888299942, 48.92590522766113), (188.7179024219513, 61.59925079345703), (215.69536972045898, 37.61261558532715), (236.4384422302246, 64.65272903442383), (235.05471992492676, 46.58933353424072), (233.83677673339844, 55.93070030212402), (240.64399337768555, 60.86867904663086), (230.85260152816772, 43.98480033874512), (220.42247533798218, 47.10324954986572), (248.25270080566406, 62.815364837646484), (236.88654136657715, 34.42378520965576), (17.71702003479004, 87.70768356323242), (19.0637149810791, 88.83516693115234), (8.883081436157227, 83.85219955444336), (18.83406639099121, 91.27460098266602), (25.591075897216797, 96.52191925048828), (13.137808799743652, 89.2390365600586), (13.91237735748291, 100.59552764892578), (4.715502738952637, 80.50706481933594), (58.911508560180664, 90.88091278076172), (52.85158157348633, 87.82322692871094), (53.97967529296875, 81.97929000854492), (49.572147369384766, 81.83305358886719), (52.451107025146484, 92.5726318359375), (40.25273513793945, 87.97761154174805), (46.59865856170654, 101.06408309936523), (32.592208564281464, 102.11711502075195), (81.16181755065918, 81.27667999267578), (81.89422798156738, 82.89550399780273), (79.48200798034668, 81.8693904876709), (75.70418167114258, 86.03783226013184), (74.23682022094727, 78.00437355041504), (74.41448497772217, 84.60126876831055), (92.62448501586914, 86.0954818725586), (77.33184146881104, 77.60823059082031), (105.00083351135254, 68.2976484298706), (95.78314632177353, 71.57714319229126), (101.3935899734497, 69.90294075012207), (112.03132438659668, 82.10178184509277), (90.74746417999268, 91.80692291259766), (99.61261653900146, 79.58180046081543), (111.10161781311035, 80.58705139160156), (94.16071724891663, 82.21338081359863), (151.63979530334473, 77.29779434204102), (154.04094696044922, 79.45513725280762), (141.4922113418579, 69.46720027923584), (142.45002460479736, 81.1851692199707), (161.17862701416016, 92.37147903442383), (147.35263442993164, 84.78189086914062), (159.1415729522705, 67.44198560714722), (145.4324893951416, 73.82951641082764), (178.6097412109375, 84.10352897644043), (173.5692024230957, 82.65268325805664), (173.2299575805664, 74.83374500274658), (160.61920940876007, 73.93945503234863), (172.21452808380127, 81.43749046325684), (164.1262664794922, 78.6096305847168), (159.1426430940628, 119.70210647583008), (154.19818449020386, 89.41856575012207), (214.9879035949707, 72.61738204956055), (211.11997985839844, 81.29093170166016), (213.6390609741211, 82.88907241821289), (208.67709350585938, 62.75358462333679), (206.22807693481445, 76.22839260101318), (215.52383995056152, 84.46983528137207), (210.9649429321289, 81.52102088928223), (209.51892852783203, 72.27112102508545), (231.4285774230957, 73.96725654602051), (233.4861717224121, 78.39017677307129), (238.73639011383057, 81.76249122619629), (239.92829990386963, 80.40158462524414), (241.41642951965332, 74.78405857086182), (221.4895100593567, 77.50855541229248), (242.58581733703613, 66.51680564880371), (232.21894073486328, 87.81247329711914), (17.16181755065918, 113.27667999267578), (17.894227981567383, 114.89550399780273), (15.48200798034668, 113.8693904876709), (11.704181671142578, 118.03783226013184), (10.236820220947266, 110.00437355041504), (10.414484977722168, 116.60126876831055), (28.62448501586914, 118.0954818725586), (13.331841468811035, 109.60823059082031), (49.16181755065918, 113.27667999267578), (49.89422798156738, 114.89550399780273), (47.48200798034668, 113.8693904876709), (43.70418167114258, 118.03783226013184), (42.236820220947266, 110.00437355041504), (42.41448497772217, 116.60126876831055), (60.62448501586914, 118.0954818725586), (45.331841468811035, 109.60823059082031), (87.89652442932129, 121.63189125061035), (80.03474998474121, 106.86541557312012), (92.86355781555176, 111.46896266937256), (104.68379211425781, 114.61712837219238), (84.77839660644531, 121.1657657623291), (80.07369995117188, 120.19780349731445), (85.26449584960938, 92.26431608200073), (79.66965007781982, 118.7575740814209), (115.53644180297852, 122.5545482635498), (110.95548057556152, 119.98477172851562), (109.00738716125488, 122.25059509277344), (100.49661111831665, 105.50899505615234), (115.12989234924316, 118.75140190124512), (105.38336849212646, 122.54631805419922), (116.99604415893555, 125.28899765014648), (91.64390993118286, 121.27290344238281), (156.2630558013916, 108.67144584655762), (153.45078659057617, 126.31956100463867), (140.54501819610596, 113.79865837097168), (140.49799633026123, 116.01822662353516), (154.96672821044922, 113.86662292480469), (138.52202033996582, 133.5740623474121), (140.64669513702393, 107.98992252349854), (139.97843647003174, 136.10368728637695), (184.21802711486816, 112.2111759185791), (187.50062561035156, 122.64651298522949), (175.6581792831421, 104.38918113708496), (170.51288223266602, 113.3090934753418), (180.44294357299805, 112.7396011352539), (168.28049087524414, 119.78403091430664), (186.30919647216797, 118.8028507232666), (168.91058826446533, 110.05706310272217), (209.4679183959961, 122.51052284240723), (206.83257865905762, 126.37354469299316), (214.48274993896484, 122.13825988769531), (203.36887168884277, 110.5274772644043), (211.4135913848877, 129.33381271362305), (201.4270534515381, 119.49334335327148), (206.2351598739624, 140.54333114624023), (190.49304866790771, 133.72532653808594), (233.698073387146, 101.81794214248657), (235.2728099822998, 110.14511966705322), (238.77400016784668, 113.63152122497559), (238.4938497543335, 116.15938568115234), (237.1205177307129, 96.48080360889435), (227.6530737876892, 109.7030086517334), (240.8657512664795, 113.19713973999023), (223.59990471601486, 115.92363929748535), (18.088472366333008, 142.146466255188), (14.168293952941895, 135.75715684890747), (26.88933753967285, 148.9205150604248), (19.690959930419922, 138.16711235046387), (10.896276473999023, 143.75884437561035), (28.51808738708496, 137.74786853790283), (17.498151779174805, 141.88325881958008), (47.4419059753418, 117.13563442230225), (38.25593900680542, 127.29435229301453), (44.4830904006958, 136.79395389556885), (45.337158203125, 148.33121299743652), (49.876211166381836, 138.73900413513184), (37.993794441223145, 130.58205795288086), (38.276047229766846, 139.40870475769043), (39.80905055999756, 153.8678207397461), (39.3426399230957, 126.96423625946045), (79.64186763763428, 158.95736122131348), (67.31096267700195, 149.01806449890137), (81.63053321838379, 145.93603706359863), (86.7177677154541, 152.58052253723145), (65.39561259746552, 160.48675537109375), (72.58897876739502, 151.40723419189453), (54.00513744354248, 139.0560483932495), (91.42024421691895, 139.20936393737793), (112.83090591430664, 144.54524612426758), (112.58893966674805, 147.42690086364746), (109.46323108673096, 152.80885314941406), (117.76003456115723, 140.7457971572876), (104.40695762634277, 136.80841255187988), (101.02729988098145, 147.1657886505127), (105.52750205993652, 150.31164360046387), (126.35803031921387, 128.80630683898926), (140.20717525482178, 144.42205238342285), (143.53483390808105, 143.15032577514648), (135.96738958358765, 143.06697273254395), (143.22618198394775, 140.72129440307617), (151.38503456115723, 137.26690673828125), (154.3672046661377, 157.59694862365723), (146.01954650878906, 144.75781440734863), (159.57390785217285, 140.67322444915771), (188.73240852355957, 160.0811538696289), (180.11220359802246, 155.78473281860352), (170.77031135559082, 150.69002532958984), (177.49742317199707, 151.67129135131836), (163.94331073760986, 152.15841102600098), (169.81975841522217, 139.96457767486572), (171.53889083862305, 136.35393524169922), (188.9234275817871, 134.91197109222412), (200.49406337738037, 153.66738319396973), (201.04920196533203, 146.03161811828613), (201.0814085006714, 142.87028884887695), (203.89949703216553, 138.42734050750732), (200.66620254516602, 147.096284866333), (194.75789308547974, 158.8874397277832), (200.4994354248047, 159.50528144836426), (202.1638536453247, 135.70386409759521), (240.83090591430664, 144.54524612426758), (240.58893966674805, 147.42690086364746), (237.46323108673096, 152.80885314941406), (245.76003456115723, 140.7457971572876), (232.40695762634277, 136.80841255187988), (229.02729988098145, 147.1657886505127), (233.52750205993652, 150.31164360046387), (254.35803031921387, 128.80630683898926), (16.83090591430664, 176.54524612426758), (16.588939666748047, 179.42690086364746), (13.463231086730957, 184.80885314941406), (21.760034561157227, 172.7457971572876), (8.406957626342773, 168.80841255187988), (5.027299880981445, 179.1657886505127), (9.527502059936523, 182.31164360046387), (30.358030319213867, 160.80630683898926), (58.11350440979004, 163.75799322128296), (53.02487564086914, 175.66109371185303), (52.50181770324707, 169.16984748840332), (42.709885597229004, 171.49230670928955), (42.8595027923584, 167.10395908355713), (45.85711193084717, 179.98370170593262), (56.22120475769043, 169.53602027893066), (66.09516143798828, 167.8397970199585), (77.3642520904541, 180.30030250549316), (73.77404499053955, 178.996919631958), (77.15626525878906, 170.1025037765503), (71.64311218261719, 170.45557594299316), (76.28396797180176, 170.24449920654297), (78.8431396484375, 188.5843505859375), (80.47684669494629, 175.59511756896973), (84.62658309936523, 172.98826122283936), (115.23396682739258, 164.5748896598816), (110.82897853851318, 172.0024709701538), (109.0111083984375, 176.97864151000977), (110.75107669830322, 179.24874877929688), (115.17449569702148, 180.5280876159668), (100.18188190460205, 177.9193058013916), (102.0774793624878, 176.89611625671387), (109.03800201416016, 176.09790802001953), (142.5787763595581, 177.48945236206055), (144.44296264648438, 178.9376735687256), (135.34583234786987, 176.56623458862305), (133.84130859375, 176.566743850708), (136.59961700439453, 177.54257583618164), (118.39071750640869, 170.07618808746338), (133.22937488555908, 162.78602981567383), (151.76956367492676, 178.98347091674805), (167.26791667938232, 160.29467418789864), (170.81818199157715, 171.83184242248535), (176.6431655883789, 180.0364646911621), (177.39429664611816, 167.62723350524902), (162.59939622879028, 164.02486181259155), (166.75820064544678, 164.797269821167), (167.96228218078613, 184.18315887451172), (164.6600399017334, 162.78610467910767), (208.83090591430664, 176.54524612426758), (208.58893966674805, 179.42690086364746), (205.46323108673096, 184.80885314941406), (213.76003456115723, 172.7457971572876), (200.40695762634277, 168.80841255187988), (197.02729988098145, 179.1657886505127), (201.52750205993652, 182.31164360046387), (222.35803031921387, 160.80630683898926), (240.83090591430664, 176.54524612426758), (240.58893966674805, 179.42690086364746), (237.46323108673096, 184.80885314941406), (245.76003456115723, 172.7457971572876), (232.40695762634277, 168.80841255187988), (229.02729988098145, 179.1657886505127), (233.52750205993652, 182.31164360046387), (254.35803031921387, 160.80630683898926), (-0.32620108127593994, 200.44958305358887), (13.881765365600586, 191.60163763165474), (9.153519630432129, 204.9348611831665), (9.909374237060547, 205.59186553955078), (14.110417366027832, 199.17728996276855), (5.809084892272949, 200.7626256942749), (25.910411834716797, 213.6365032196045), (-5.998323440551758, 187.48252868652344), (49.640119552612305, 222.0856475830078), (44.22492980957031, 217.84284591674805), (51.623830795288086, 213.8425521850586), (50.68075752258301, 209.27023315429688), (39.92790222167969, 223.55502319335938), (36.637328147888184, 201.84335803985596), (38.202319622039795, 215.2762680053711), (48.59750175476074, 212.51626014709473), (81.16181755065918, 209.27667999267578), (81.89422798156738, 210.89550399780273), (79.48200798034668, 209.8693904876709), (75.70418167114258, 214.03783226013184), (74.23682022094727, 206.00437355041504), (74.41448497772217, 212.60126876831055), (92.62448501586914, 214.0954818725586), (77.33184146881104, 205.6082305908203), (126.45676231384277, 207.71591567993164), (108.15489959716797, 195.29697275161743), (126.42856216430664, 192.8834027647972), (113.9249095916748, 223.17632293701172), (118.65874099731445, 213.11674690246582), (119.49366760253906, 205.0375690460205), (109.90594387054443, 206.93012142181396), (113.30722999572754, 206.04669094085693), (128.51267230510712, 203.17236614227295), (139.63444709777832, 203.12344551086426), (137.1880226135254, 209.045747756958), (144.122953414917, 206.87202739715576), (145.28418922424316, 222.664945602417), (136.0320634841919, 218.7495517730713), (147.04206657409668, 225.63541412353516), (122.00974750518799, 209.65429496765137), (181.7479362487793, 192.3573446571827), (185.5712070465088, 199.55690813064575), (175.91235256195068, 202.92279815673828), (173.83031272888184, 216.67082977294922), (177.98317527770996, 208.75911712646484), (178.83702659606934, 209.25236320495605), (190.01596069335938, 209.74835777282715), (175.44731903076172, 195.79806995391846), (214.29232215881348, 213.0513210296631), (209.41476821899414, 197.72892379760742), (221.5943660736084, 199.96707773208618), (225.39230728149414, 217.00444412231445), (204.0044298171997, 196.4077787399292), (212.28168106079102, 193.30711889266968), (207.21258354187012, 199.7065577507019), (212.32355117797852, 196.38356351852417), (236.70989227294922, 197.33735847473145), (235.08431434631348, 194.2339470386505), (241.42663955688477, 201.71349430084229), (232.3297576904297, 195.3539912700653), (236.31072902679443, 204.13848495483398), (246.89215278625488, 194.3105547428131), (258.21673583984375, 188.41398668289185), (248.20135116577148, 188.35548639297485), (11.090085983276367, 234.3545618057251), (13.209890365600586, 226.00442576408386), (16.370569229125977, 224.41557604074478), (24.234968185424805, 242.3834056854248), (17.108612060546875, 237.07029056549072), (16.946531295776367, 235.42683601379395), (35.88199996948242, 223.0850135087967), (22.945241928100586, 225.68839061260223), (49.16181755065918, 241.27667999267578), (49.89422798156738, 242.89550399780273), (47.48200798034668, 241.8693904876709), (43.70418167114258, 246.03783226013184), (42.236820220947266, 238.00437355041504), (42.41448497772217, 244.60126876831055), (60.62448501586914, 246.0954818725586), (45.331841468811035, 237.6082305908203), (75.31252765655518, 237.134015083313), (79.28474617004395, 235.07818698883057), (78.38941383361816, 233.2282304763794), (80.67273139953613, 237.9066972732544), (64.80514121055603, 240.88675498962402), (77.92364597320557, 244.73186874389648), (105.94889068603516, 221.02940130233765), (83.94301414489746, 237.26792907714844), (109.15278244018555, 253.43519973754883), (105.86784553527832, 252.41526794433594), (113.56908798217773, 243.31297302246094), (100.24453210830688, 250.73031997680664), (116.44934844970703, 230.62885570526123), (101.23382139205933, 235.20590686798096), (100.19014072418213, 265.74633407592773), (98.62012434005737, 244.84444046020508), (141.92821407318115, 243.11892890930176), (148.7746124267578, 242.46412467956543), (150.9156894683838, 248.09185600280762), (139.9674587249756, 236.90926551818848), (142.10357093811035, 248.09311866760254), (141.7936201095581, 254.36943244934082), (135.34451389312744, 265.2713813781738), (130.20015597343445, 246.98081588745117), (177.16181755065918, 241.27667999267578), (177.89422798156738, 242.89550399780273), (175.48200798034668, 241.8693904876709), (171.70418167114258, 246.03783226013184), (170.23682022094727, 238.00437355041504), (170.41448497772217, 244.60126876831055), (188.62448501586914, 246.0954818725586), (173.33184146881104, 237.6082305908203), (209.16181755065918, 241.27667999267578), (209.89422798156738, 242.89550399780273), (207.48200798034668, 241.8693904876709), (203.70418167114258, 246.03783226013184), (202.23682022094727, 238.00437355041504), (202.41448497772217, 244.60126876831055), (220.62448501586914, 246.0954818725586), (205.33184146881104, 237.6082305908203), (234.60764694213867, 232.01544189453125), (253.39385223388672, 234.99650859832764), (235.1248016357422, 238.43648719787598), (244.08147811889648, 228.94715690612793), (238.2197675704956, 244.5550422668457), (241.67731285095215, 234.08039665222168), (233.58935165405273, 244.1219425201416), (221.4117293357849, 237.82540130615234)]\n" + ] + } + ], + "source": [ + "reconstructed_image, true_hits, predicted_hits = predict_and_visualize(\n", + " model, data_loader, val_dataset, img_idx=0, tile_size=32\n", + ")\n", + "\n", + "# Inspect true and predicted hits\n", + "print(\"True Hit Centers:\", true_hits)\n", + "print(\"Predicted Hit Centers:\", predicted_hits)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_tiles_with_hits(image_tiles, true_centers, predicted_centers, tile_size=8, max_hits_per_tile=2):\n", + " \"\"\"\n", + " Visualizes individual tiles of an image with ground truth and predicted hits overlaid.\n", + "\n", + " Parameters:\n", + " - image_tiles: np.array, array of image tiles with shape (num_tiles, tile_size, tile_size).\n", + " - true_centers: np.array, true hit locations for each tile, shape (num_tiles, max_hits_per_tile, 2).\n", + " - predicted_centers: np.array, predicted hit locations for each tile, shape (num_tiles, max_hits_per_tile, 2).\n", + " - tile_size: int, size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " \"\"\"\n", + " num_tiles = len(image_tiles)\n", + " grid_size = int(np.sqrt(num_tiles)) # Assumes square grid of tiles\n", + "\n", + " fig, axes = plt.subplots(grid_size, grid_size, figsize=(18, 18))\n", + "\n", + " for idx, (tile, true_tile_centers, pred_tile_centers) in enumerate(zip(image_tiles, true_centers, predicted_centers)):\n", + " row = idx // grid_size\n", + " col = idx % grid_size\n", + " ax = axes[row, col]\n", + " \n", + " # Display the tile\n", + " ax.imshow(tile, cmap='gray')\n", + " ax.axis('on')\n", + "\n", + " # Plot true hits (green crosses)\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, color='green', marker='x', label=\"True\" if idx == 0 else \"\")\n", + "\n", + " # Plot predicted hits (red circles)\n", + " for (x, y) in pred_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, color='red', marker='o', label=\"Predicted\" if idx == 0 else \"\")\n", + "\n", + " # Add a single legend outside the grid\n", + " handles, labels = axes[0, 0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right', fontsize=5)\n", + " plt.suptitle(\"Tiles with True (green) and Predicted (red) Hits\", fontsize=5)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def predict_and_visualize_tiles_with_hits(model, data_loader, dataset, img_idx, tile_size=8, max_hits_per_tile=2):\n", + " \"\"\"\n", + " Visualizes tiles with true and predicted hit locations overlaid.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access image and tile information.\n", + " - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " - tile_size: int, size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " \"\"\"\n", + " grid_size = 256 // tile_size # Example assumes 256x256 image size\n", + " \n", + " # Extract tiles and centers\n", + " cumulative_images = 0\n", + " for batch_images, batch_true_centers in dataset:\n", + " num_tiles_in_batch = batch_images.shape[0]\n", + " num_images_in_batch = num_tiles_in_batch // (grid_size ** 2)\n", + "\n", + " if cumulative_images + num_images_in_batch > img_idx:\n", + " batch_img_idx = img_idx - cumulative_images\n", + " start_idx = batch_img_idx * grid_size**2\n", + " end_idx = (batch_img_idx + 1) * grid_size**2\n", + " image_tiles = batch_images[start_idx:end_idx]\n", + " true_centers_tiles = batch_true_centers[start_idx:end_idx]\n", + " break\n", + "\n", + " cumulative_images += num_images_in_batch\n", + "\n", + " # Make predictions\n", + " predictions = model.predict(image_tiles)\n", + " predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + " # Visualize tiles with hits\n", + " visualize_tiles_with_hits(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size),\n", + " true_centers_tiles.numpy().reshape(-1, 2, 2),\n", + " predicted_centers,\n", + " tile_size,\n", + " max_hits_per_tile\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 17:48:08.447953: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Assuming `model`, `data_loader`, and `val_dataset` are already defined\n", + "predict_and_visualize_tiles_with_hits(model, data_loader, val_dataset, img_idx=0, tile_size=8)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss_debug3(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0), return_indices=False):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1) \n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " \n", + " if return_indices:\n", + " return sorted_midpoints, sorted_indices\n", + " else:\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort y_true and get indices\n", + " y_true_sorted, sorted_indices = sort_midpoints_by_distance(y_true, reference_point, return_indices=True)\n", + " \n", + " # Reshape y_pred to match midpoints format\n", + " y_pred = tf.reshape(y_pred, (-1, tf.shape(y_pred)[-1] // 2, 2))\n", + " \n", + " # Sort y_pred using the indices from y_true\n", + " y_pred_sorted = tf.gather(y_pred, sorted_indices, batch_dims=1)\n", + " \n", + " # Create a mask to identify ground truth values with (0,0)\n", + " zero_mask = tf.reduce_all(tf.equal(y_true_sorted, [0.0, 0.0]), axis=-1) # Shape: (batch_size, num_midpoints)\n", + "\n", + " # Assign -2 to predictions corresponding to (0,0) ground truths\n", + " y_pred_adjusted = tf.where(\n", + " tf.expand_dims(zero_mask, axis=-1), # Expand dimensions for broadcasting\n", + " tf.constant([0.0, 0.0], dtype=y_pred_sorted.dtype), # Assign value\n", + " y_pred_sorted # Keep original predictions\n", + " )\n", + "\n", + " # Create a mask for valid points (non-zero ground truths)\n", + " nonzero_mask = tf.logical_not(zero_mask)\n", + "\n", + " def compute_loss():\n", + " # Apply the mask to filter out invalid points\n", + " y_true_masked = tf.boolean_mask(y_true_sorted, nonzero_mask)\n", + " y_pred_masked = tf.boolean_mask(y_pred_adjusted, nonzero_mask)\n", + "\n", + " # Compute the difference\n", + " diff = tf.abs(y_true_masked - y_pred_masked)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " def return_zero():\n", + " return tf.constant(0.0, dtype=tf.float32)\n", + " \n", + " # Use tf.cond to decide which branch to execute\n", + " return tf.cond(tf.reduce_any(nonzero_mask), compute_loss, return_zero)\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss value: tf.Tensor(4.8487496, shape=(), dtype=float32)\n" + ] + } + ], + "source": [ + "loss_fn = euclidean_sorted_custom_loss_debug3(exponent=2)\n", + "\n", + "# Example data\n", + "y_true = tf.constant([[1.0, 1.0, 1, 0.0, 3.0, 3.0,0,1]])\n", + "# y_true = tf.constant([[0, 0, 0.0, 0.0, 0, 0]])\n", + "y_pred = tf.constant([[5, 5, 2.1, 2.1, 3.1, 3.4]])\n", + "# y_pred_2 =tf.constant([[1.1, 1.1, 0, 0, 3.1, 3.4]])\n", + "\n", + "# y_true = tf.constant([[1.0, 1.0]])\n", + "# y_pred = tf.constant([[1.1, 1.1]])\n", + "\n", + "loss_value = loss_fn(y_true, y_pred)\n", + "print(\"Loss value:\", loss_value)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "# Reshaping into (3, 2)\n", + "reshaped_y_true = tf.reshape(y_true, (-1, 2))\n", + "sorted_indices = tf.argsort(reshaped_y_true, axis=-1) \n", + "# Output the reshaped tensor\n", + "sorted_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reshaped_y_true" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Electron Counting Tiling approach/32 by 32 images.ipynb b/Electron Counting Tiling approach/32 by 32 images.ipynb new file mode 100644 index 0000000..8bddc08 --- /dev/null +++ b/Electron Counting Tiling approach/32 by 32 images.ipynb @@ -0,0 +1,2265 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:26:59.410115: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-11 22:26:59.422897: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-11 22:26:59.435701: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-11 22:26:59.439554: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-11 22:26:59.450647: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-11 22:27:00.077392: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:27:01.607391: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 78221 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-11 22:27:01.608928: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79070 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-11 22:27:01.610258: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import h5py\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " return images, centers\n", + "\n", + " def sort_centers(self, centers):\n", + " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [hits_per_tile[i] for i in range(len(tiles))]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " \"\"\"\n", + " Pads or truncates the hit coordinates for each tile to a fixed size (max_hits_per_tile).\n", + " \"\"\"\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + " return np.array(padded_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + "\n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_centers = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_centers, train_size=train_size, random_state=random_state)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/20KFixed_Mixed_5_32by32_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_377777/1698765166.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + "\n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images and centers\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + " flat_centers = centers.reshape(-1, max_hits_per_tile * 2) # Flatten hit locations\n", + "\n", + " return flat_images, flat_centers\n", + "\n", + "# Flatten the training and validation datasets\n", + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "val_images_flat, val_centers_flat = flatten_dataset(val_images, val_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Create TensorFlow datasets from the flattened data\n", + "batch_size = 1000\n", + "train_dataset_flat = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + "val_dataset_flat = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0, 1.0, 0.875, 0.875)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(train_images), np.max(val_images), np.max(train_midpoints), np.max(val_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 0.0, 0.0, 0.0)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(train_images), np.min(val_images), np.min(train_midpoints), np.min(val_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_image_with_tiles_and_centers(data_loader, img_idx=0):\n", + " \"\"\"\n", + " Visualizes an image alongside its corresponding tiles with hit centers overlaid.\n", + "\n", + " Parameters:\n", + " - data_loader: DataLoader, the instance of DataLoader to access image and center data.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " \"\"\"\n", + " # Get the image and corresponding centers\n", + " image = data_loader.images[img_idx]\n", + " centers = data_loader.centers[img_idx]\n", + " \n", + " # Tile the image and map the centers to the tiles\n", + " tiles, hits_per_tile = data_loader.map_hits_to_tiles(image, centers)\n", + " num_tiles_per_row = int(image.shape[0] / data_loader.tile_size) # Assuming square grid of tiles\n", + "\n", + " # Create a figure grid for the original image and its tiles\n", + " fig, axs = plt.subplots(num_tiles_per_row + 1, num_tiles_per_row, figsize=(12, 12))\n", + " fig.suptitle(\"Original Image and Tiles with Hit Centers\", fontsize=16)\n", + "\n", + " # Display the original image with centers\n", + " axs[0, 0].imshow(image, cmap='gray')\n", + " axs[0, 0].set_title(\"Original Image\")\n", + " axs[0, 0].axis('off')\n", + " for (_, x, y) in centers:\n", + " axs[0, 0].scatter(x, y, color='red', marker='x') # Plot hit centers on original image\n", + "\n", + " # Hide unused axes in the first row, if any\n", + " for j in range(1, num_tiles_per_row):\n", + " axs[0, j].axis('off')\n", + "\n", + " # Plot each tile with centers marked\n", + " for idx, tile in enumerate(tiles):\n", + " row = idx // num_tiles_per_row + 1\n", + " col = idx % num_tiles_per_row\n", + " axs[row, col].imshow(tile, cmap='gray')\n", + " axs[row, col].set_title(f\"Tile {idx}\")\n", + " axs[row, col].axis('on')\n", + " \n", + " # Plot centers within the tile\n", + " for (x, y) in hits_per_tile[idx]:\n", + " axs[row, col].scatter(x, y, color='red', marker='x') # Mark center within tile coordinates\n", + "\n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.9) # Adjust spacing to fit title\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "h = np.random.randint(0, 10000)\n", + "# Call the function with your DataLoader instance\n", + "visualize_image_with_tiles_and_centers(data_loader, img_idx=h) # Visualize the first image with centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n", + " super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n", + "2024-11-11 22:28:37.882404: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-11 22:28:37.910616: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-11 22:28:37.945299: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731364117.991466 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364117.991466 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.006619 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053070 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053130 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053152 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053623 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053721 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.053799 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.059094 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.059094 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.059201 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.075334 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.075404 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.075455 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.077613 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.077623 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.077751 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078402 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078403 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078567 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078868 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.078937 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.079148 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.081256 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.081268 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.081397 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098258 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098387 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098589 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098742 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.098850 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099225 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099261 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099361 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099664 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099879 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.099891 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100092 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100257 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100520 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100527 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100678 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.100853 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.101138 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.102521 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.102531 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.102661 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.104530 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.104532 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.104669 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.106943 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.107134 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.107265 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.109725 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.109769 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.109899 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.112007 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.112124 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.112161 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.113868 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.113911 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.114068 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.114196 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.115327 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.115346 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.115539 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.122152 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.122188 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.122312 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.124125 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.124296 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.124331 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.204811 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205157 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205367 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205424 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205627 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.205898 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206079 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206257 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206447 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206486 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206667 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.206965 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207096 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207193 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207415 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207625 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.207638 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208066 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208139 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208374 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208422 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208597 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208977 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.208994 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.209138 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.209360 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.209703 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.209907 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.210012 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.210470 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.210602 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.210810 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211035 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211260 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211327 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211541 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211827 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.211853 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.212007 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.212203 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.212441 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.213040 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.213457 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.213492 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.213565 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.214718 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.214739 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.214817 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215298 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215333 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215538 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215838 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.215874 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216084 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216365 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216384 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216540 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216840 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.216849 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217115 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217362 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217416 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217679 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217914 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.217951 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.218048 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.218280 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.219774 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.219865 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220009 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220290 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220351 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220551 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220846 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220883 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.220988 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.227421 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.227433 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.227527 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.227866 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228070 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228116 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228417 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228650 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.228662 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.229036 378145 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.229476 378138 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.229493 378133 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 8/128\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 0.0164 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731364118.456302 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.456347 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.457726 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.457859 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.458066 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.458213 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.459979 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460048 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460377 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460473 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460847 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.460920 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.463327 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.463421 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.463632 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.463733 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.466365 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.466381 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.471197 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.472341 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.472680 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.472854 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.472939 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.473211 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.473367 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.473805 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.473824 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474028 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474349 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474370 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474576 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474870 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.474902 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.475453 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.475586 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.475822 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.477226 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.477243 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.477259 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.478655 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.478886 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.478941 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.479154 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.479342 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.479480 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.479706 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480046 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480054 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480267 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480500 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480680 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.480991 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481009 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481577 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481637 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481774 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.481992 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.482110 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.482342 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.482986 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.483331 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.483539 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.483547 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.484011 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.484803 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485080 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485171 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485485 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485797 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.485876 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486205 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486334 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486417 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486567 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.486828 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.487177 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.487244 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.487523 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.488304 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.488476 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.488490 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.518538 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.518967 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.519557 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.520754 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.520773 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.520791 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.522396 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.522468 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.522479 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.524479 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.524554 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.524611 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525173 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525248 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525265 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525719 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525800 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.525813 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.527736 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.527754 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.527833 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529241 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529240 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529260 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529879 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529946 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.529959 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.530836 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.530855 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.530933 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.532903 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.532904 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.532922 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.533866 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.533949 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.533960 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.534781 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.534859 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.534869 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.536368 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.536475 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.536555 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.537281 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.537310 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.537388 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556261 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556324 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556393 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556838 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.556848 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557058 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557256 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557305 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557526 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557707 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557764 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.557986 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.558184 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.558232 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.558343 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.559379 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.559456 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.559467 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561247 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561321 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561333 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561795 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561889 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.561904 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.562270 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.562564 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.562597 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.562740 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563167 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563272 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563290 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563551 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563820 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.563830 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.564278 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.564290 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.569388 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.569470 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.569480 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570131 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570271 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570380 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570685 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.570784 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571019 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571279 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571302 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571414 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571778 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571987 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.571997 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.572225 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.572644 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.572655 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.572872 378140 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.573512 378147 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364118.573523 378143 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m126/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - loss: 0.0085" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:39.606965: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-11 22:28:39.607047: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-11 22:28:39.607202: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731364119.992246 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.992278 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.992735 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.997247 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.997334 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.997348 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.997694 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998027 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998093 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998261 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998550 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998744 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.998890 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999053 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999407 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999482 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999714 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364119.999893 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.000014 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.000461 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.000493 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.000571 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001063 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001083 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001201 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001767 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001772 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.001791 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.002419 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.002426 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.002465 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.002908 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003034 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003129 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003455 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003602 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.003734 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004082 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004217 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004341 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004663 378135 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004735 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.004856 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.005240 378141 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731364120.005348 378137 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 14ms/step - loss: 0.0084 - val_loss: 0.0020\n", + "Epoch 2/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:40.389731: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m122/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 0.0016" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:41.652768: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 0.0016 - val_loss: 0.0012\n", + "Epoch 3/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 0.0011 - val_loss: 9.9566e-04\n", + "Epoch 4/50\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m17s\u001b[0m 137ms/step - loss: 0.0014" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:43.077966: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 9.1517e-04 - val_loss: 9.2282e-04\n", + "Epoch 5/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 8.4224e-04 - val_loss: 8.8962e-04\n", + "Epoch 6/50\n", + "\u001b[1m122/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - loss: 7.9947e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:46.934348: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 7.9850e-04 - val_loss: 8.6625e-04\n", + "Epoch 7/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 7.6558e-04 - val_loss: 8.4494e-04\n", + "Epoch 8/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 7.3690e-04 - val_loss: 8.2635e-04\n", + "Epoch 9/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 7.0954e-04 - val_loss: 8.1297e-04\n", + "Epoch 10/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 6.8438e-04 - val_loss: 7.9440e-04\n", + "Epoch 11/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 6.6196e-04 - val_loss: 7.8117e-04\n", + "Epoch 12/50\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m17s\u001b[0m 139ms/step - loss: 8.1208e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:28:53.370095: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 6.4179e-04 - val_loss: 7.7241e-04\n", + "Epoch 13/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 6.2463e-04 - val_loss: 7.6190e-04\n", + "Epoch 14/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 6.0991e-04 - val_loss: 7.5480e-04\n", + "Epoch 15/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.9718e-04 - val_loss: 7.5351e-04\n", + "Epoch 16/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.8630e-04 - val_loss: 7.5459e-04\n", + "Epoch 17/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.7694e-04 - val_loss: 7.5569e-04\n", + "Epoch 18/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.6865e-04 - val_loss: 7.5895e-04\n", + "Epoch 19/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.5979e-04 - val_loss: 7.6116e-04\n", + "Epoch 20/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.5267e-04 - val_loss: 7.6509e-04\n", + "Epoch 21/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.4572e-04 - val_loss: 7.6805e-04\n", + "Epoch 22/50\n", + "\u001b[1m124/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 6ms/step - loss: 5.3867e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:29:07.534414: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.3858e-04 - val_loss: 7.7136e-04\n", + "Epoch 23/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.3156e-04 - val_loss: 7.7555e-04\n", + "Epoch 24/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.2507e-04 - val_loss: 7.7657e-04\n", + "Epoch 25/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 5.1843e-04 - val_loss: 7.8298e-04\n", + "Epoch 26/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.1206e-04 - val_loss: 7.8483e-04\n", + "Epoch 27/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 5.0663e-04 - val_loss: 7.9219e-04\n", + "Epoch 28/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.9985e-04 - val_loss: 7.9633e-04\n", + "Epoch 29/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.9338e-04 - val_loss: 8.0354e-04\n", + "Epoch 30/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.8780e-04 - val_loss: 8.1546e-04\n", + "Epoch 31/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.8193e-04 - val_loss: 8.2067e-04\n", + "Epoch 32/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.7664e-04 - val_loss: 8.2672e-04\n", + "Epoch 33/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 9ms/step - loss: 4.7026e-04 - val_loss: 8.3414e-04\n", + "Epoch 34/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.6551e-04 - val_loss: 8.4403e-04\n", + "Epoch 35/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.5926e-04 - val_loss: 8.4788e-04\n", + "Epoch 36/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.5397e-04 - val_loss: 8.5360e-04\n", + "Epoch 37/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.4883e-04 - val_loss: 8.6109e-04\n", + "Epoch 38/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 4.4539e-04 - val_loss: 8.6610e-04\n", + "Epoch 39/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.3821e-04 - val_loss: 8.7378e-04\n", + "Epoch 40/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.3356e-04 - val_loss: 8.8890e-04\n", + "Epoch 41/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 4.2916e-04 - val_loss: 8.8778e-04\n", + "Epoch 42/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 4.2336e-04 - val_loss: 8.9218e-04\n", + "Epoch 43/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.1905e-04 - val_loss: 9.0233e-04\n", + "Epoch 44/50\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m18s\u001b[0m 142ms/step - loss: 3.3601e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 22:29:36.141124: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.1469e-04 - val_loss: 9.1067e-04\n", + "Epoch 45/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 4.1099e-04 - val_loss: 9.1877e-04\n", + "Epoch 46/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 4.0566e-04 - val_loss: 9.2916e-04\n", + "Epoch 47/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 4.0140e-04 - val_loss: 9.3635e-04\n", + "Epoch 48/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 3.9789e-04 - val_loss: 9.4423e-04\n", + "Epoch 49/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step - loss: 3.9460e-04 - val_loss: 9.5438e-04\n", + "Epoch 50/50\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 3.9048e-04 - val_loss: 9.6507e-04\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "\n", + "# Define the model\n", + "def create_model(input_shape=(8, 8, 1), max_hits=5):\n", + " model = tf.keras.Sequential([\n", + " tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),\n", + " tf.keras.layers.MaxPooling2D((2, 2)),\n", + " tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " tf.keras.layers.Flatten(),\n", + " tf.keras.layers.Dense(128, activation='relu'),\n", + " tf.keras.layers.Dense(max_hits * 2) # Predict x and y for each hit, so output shape is (max_hits * 2,)\n", + " ])\n", + " return model\n", + "with strategy.scope():\n", + " # Create an instance of the model\n", + " model = create_model()\n", + "\n", + " # Compile the model\n", + " model.compile(optimizer='adam', loss='mse')\n", + "\n", + "# Train the model\n", + "history = model.fit(\n", + " train_dataset_flat, # Dataset prepared in your previous code\n", + " validation_data=val_dataset_flat,\n", + " epochs=50,\n", + " batch_size=1000\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot sample tiles and hit locations\n", + "v = np.random.randint(0, len(data_loader.images))\n", + "tiles, hits_per_tile = data_loader.map_hits_to_tiles(data_loader.images[v], data_loader.centers[v])\n", + "\n", + "fig, axs = plt.subplots(4, 4, figsize=(12, 12))\n", + "for i, ax in enumerate(axs.flat):\n", + " tile = tiles[i]\n", + " hits = hits_per_tile[i]\n", + " \n", + " ax.imshow(tile, cmap='gray')\n", + " for (x, y) in hits:\n", + " ax.scatter(x, y, c='red', marker='x')\n", + " ax.axis('on')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + "# # Reshape reference_point to match the shape of midpoints for broadcasting\n", + "# reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + "# reference_point = tf.reshape(reference_point, (1, 1, 2)) # Shape (1, 1, 2)\n", + " \n", + "# # Reshape midpoints to (batch_size, num_hits, 2) for sorting\n", + "# midpoints = tf.reshape(midpoints, (-1, 5, 2)) # Assuming 5 hits per image\n", + " \n", + "# # Calculate Euclidean distances from the reference point\n", + "# distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_hits)\n", + " \n", + "# # Get sorted indices based on distances\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + "# # Gather sorted midpoints\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# # Define the reference point\n", + "# reference_point = (0.0, 0.0)\n", + " \n", + "# # Sort both y_true and y_pred based on distances from the reference point\n", + "# y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + "# y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + "# # Calculate Euclidean distance between sorted true and predicted midpoints\n", + "# diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss across all coordinates\n", + "# return tf.reduce_mean(powered_diff)\n", + " \n", + "# return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "# import matplotlib.pyplot as plt\n", + "# import numpy as np\n", + "# import random\n", + "\n", + "# def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + "# \"\"\"\n", + "# Reconstructs the original image from tiles.\n", + "\n", + "# Parameters:\n", + "# - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + "# - tile_size: int, the size of each tile.\n", + "# - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + "# Returns:\n", + "# - image: np.array, the reconstructed original image.\n", + "# \"\"\"\n", + "# reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + "# for idx, tile in enumerate(tiles):\n", + "# row = (idx // num_tiles_per_row) * tile_size\n", + "# col = (idx % num_tiles_per_row) * tile_size\n", + "# reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "# return reconstructed_image\n", + "\n", + "# def visualize_predictions_with_original(model, dataset, tile_size=8, max_hits_per_tile=5, num_images=1, threshold=0.1):\n", + "# \"\"\"\n", + "# Visualizes the model's predictions on a random sample of images from the dataset,\n", + "# showing both the original image and tiled predictions.\n", + "\n", + "# Parameters:\n", + "# - model: tf.keras.Model, the trained model to make predictions.\n", + "# - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + "# - tile_size: int, the size of each tile.\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "# - num_images: int, number of random images to visualize.\n", + "# - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + "# \"\"\"\n", + "# # Take one batch from the dataset for prediction\n", + "# images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + "# # Randomly select indices of images to visualize\n", + "# indices = random.sample(range(images.shape[0] // 4), num_images)\n", + "\n", + "# # Make predictions on the batch\n", + "# predictions = model.predict(images)\n", + "\n", + "# # Visualize the selected images\n", + "# for img_idx in indices:\n", + "# # Reconstruct the original image from tiles\n", + "# tiles = images[img_idx * 4 : (img_idx + 1) * 4]\n", + "# reconstructed_image = reconstruct_image_from_tiles(tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 2) # Assuming 2x2 tiles for 4 tiles per image\n", + "\n", + "# # Plot the original image with overlayed predictions\n", + "# fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + "# ax_orig.imshow(reconstructed_image, cmap='gray')\n", + "# ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + "# # Overlay true and predicted centers on the original image\n", + "# for tile_idx in range(4): # Assuming 2x2 tiles\n", + "# row_offset = (tile_idx // 2) * tile_size\n", + "# col_offset = (tile_idx % 2) * tile_size\n", + "\n", + "# # Get true and predicted centers for each tile\n", + "# true_tile_centers = true_centers[img_idx * 4 + tile_idx].numpy().reshape(-1, 2)\n", + "# predicted_tile_centers = predictions[img_idx * 4 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + "# # Plot true hits in green\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot predicted hits in red, with threshold check\n", + "# for (x, y) in predicted_tile_centers:\n", + "# # Ignore (0, 0) or predictions close to it\n", + "# if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Add legend\n", + "# handles, labels = ax_orig.get_legend_handles_labels()\n", + "# ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + "# # Now plot the tiled images with predictions\n", + "# fig, axs = plt.subplots(4, 4, figsize=(6, 6))\n", + "# fig.suptitle(f\"Tiled Predictions (Image {img_idx})\")\n", + "\n", + "# for tile_idx, ax in enumerate(axs.flat):\n", + "# true_tile_centers = true_centers[img_idx * 4 + tile_idx].numpy().reshape(-1, 2)\n", + "# predicted_tile_centers = predictions[img_idx * 4 + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + "# # Display the tile\n", + "# ax.imshow(images[img_idx * 4 + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + "# # Plot true centers\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot predicted centers with threshold check\n", + "# for (x, y) in predicted_tile_centers:\n", + "# # Ignore (0, 0) or predictions close to it\n", + "# if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + "# ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# ax.axis('off')\n", + "\n", + "# handles, labels = axs[0, 0].get_legend_handles_labels()\n", + "# fig.legend(handles, labels, loc='upper right')\n", + "# plt.tight_layout()\n", + "# plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # Example usage\n", + "# visualize_predictions_with_original(model, val_dataset_flat, tile_size=8, max_hits_per_tile=5, num_images=2, threshold=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import random\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " return reconstructed_image\n", + "\n", + "def aggregate_predictions_across_tiles(predicted_hits, max_hits=5):\n", + " \"\"\"\n", + " Aggregates predicted hits across all tiles in the parent image and limits\n", + " to a maximum of `max_hits`.\n", + "\n", + " Parameters:\n", + " - predicted_hits: list of tuples with (x, y) coordinates of predicted hits.\n", + " - max_hits: int, maximum number of hits allowed per parent image.\n", + "\n", + " Returns:\n", + " - aggregated_hits: list of tuples with (x, y) coordinates limited to max_hits.\n", + " \"\"\"\n", + " # Sort by distance from origin (or by another criteria if available) and pick top `max_hits`\n", + " # Here we just truncate for simplicity; in practice, use model-provided confidence if available.\n", + " if len(predicted_hits) > max_hits:\n", + " return predicted_hits[:max_hits]\n", + " return predicted_hits\n", + "\n", + "def visualize_predictions_with_constraints(model, dataset, tile_size=8, max_hits_per_image=5, num_images=1, threshold=0.1):\n", + " \"\"\"\n", + " Visualizes the model's predictions on a random sample of images from the dataset,\n", + " showing both the original image and tiled predictions.\n", + "\n", + " Parameters:\n", + " - model: tf.keras.Model, the trained model to make predictions.\n", + " - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_image: int, maximum number of hits allowed per parent image.\n", + " - num_images: int, number of random images to visualize.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \"\"\"\n", + " images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + " indices = random.sample(range(images.shape[0] // 16), num_images)\n", + " predictions = model.predict(images)\n", + "\n", + " for img_idx in indices:\n", + " tiles = images[img_idx * 16 : (img_idx + 1) * 16]\n", + " reconstructed_image = reconstruct_image_from_tiles(tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 4)\n", + "\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + " all_predicted_hits = []\n", + "\n", + " for tile_idx in range(16): # 4x4 grid\n", + " row_offset = (tile_idx // 4) * tile_size\n", + " col_offset = (tile_idx % 4) * tile_size\n", + "\n", + " true_tile_centers = true_centers[img_idx * 16 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 16 + tile_idx].reshape(5, 2) # Assuming 5 predictions max per tile\n", + "\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + " all_predicted_hits.append((col_offset + x * tile_size, row_offset + y * tile_size))\n", + "\n", + " limited_predicted_hits = aggregate_predictions_across_tiles(all_predicted_hits, max_hits=max_hits_per_image)\n", + "\n", + " for (x, y) in limited_predicted_hits:\n", + " ax_orig.scatter(x, y, c='red', marker='o', s=30, label='Predicted Hit' if x == limited_predicted_hits[0][0] else \"\")\n", + "\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + " fig, axs = plt.subplots(4, 4, figsize=(8, 8))\n", + " fig.suptitle(f\"Tiled Predictions (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " true_tile_centers = true_centers[img_idx * 16 + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * 16 + tile_idx].reshape(5, 2)\n", + "\n", + " ax.imshow(images[img_idx * 16 + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0):\n", + " ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0) and (x**2 + y**2) > threshold**2:\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " ax.axis('off')\n", + "\n", + " handles, labels = axs[0, 0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 3ms/step \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage\n", + "visualize_predictions_with_constraints(model, val_dataset_flat, tile_size=8, max_hits_per_image=5, num_images=1, threshold=0.1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_centers_flat[43]" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((128000, 8, 8, 1), (128000, 10))" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images_flat.shape, train_centers_flat.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"sequential\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 32)       │           320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 32)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        18,496 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 10)             │         1,290 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m1,290\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 85,280 (333.13 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m85,280\u001b[0m (333.13 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 28,426 (111.04 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m28,426\u001b[0m (111.04 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Optimizer params: 56,854 (222.09 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m56,854\u001b[0m (222.09 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tiled images shape: (10000, 16, 8, 8)\n", + "Tiled centers shape: (10000, 16)\n", + "Flattened train images shape: (128000, 8, 8, 1)\n", + "Flattened train centers shape: (128000, 10)\n", + "Sample flattened image tile: [[0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]]\n", + "Sample flattened centers: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "Epoch 1/5\n", + "\u001b[1m 1/128\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m16s\u001b[0m 131ms/step - loss: 2.9621e-04" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_377777/1698765166.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 15ms/step - loss: 3.8614e-04 - val_loss: 9.6683e-04\n", + "Epoch 2/5\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 3.8246e-04 - val_loss: 9.7807e-04\n", + "Epoch 3/5\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step - loss: 3.8066e-04 - val_loss: 9.8486e-04\n", + "Epoch 4/5\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 3.7556e-04 - val_loss: 9.9021e-04\n", + "Epoch 5/5\n", + "\u001b[1m128/128\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 10ms/step - loss: 3.7251e-04 - val_loss: 0.0010\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 168ms/step\n", + "Predicted hit centers for sample validation tiles: [[ 3.87402996e-03 1.10752136e-03 -2.85455212e-03 -2.44698487e-04\n", + " -1.07228756e-04 1.69471279e-03 -1.39096286e-04 -1.06428721e-04\n", + " 2.21667811e-04 -6.67363405e-04]\n", + " [ 3.87402996e-03 1.10752136e-03 -2.85455212e-03 -2.44698487e-04\n", + " -1.07228756e-04 1.69471279e-03 -1.39096286e-04 -1.06428721e-04\n", + " 2.21667811e-04 -6.67363405e-04]\n", + " [ 4.94345486e-01 2.54629374e-01 9.77038406e-03 -8.84084310e-03\n", + " -5.95828518e-04 3.74388508e-03 5.12754079e-04 -5.72215999e-04\n", + " 1.24042947e-03 -3.46343964e-03]\n", + " [ 3.87402996e-03 1.10752136e-03 -2.85455212e-03 -2.44698487e-04\n", + " -1.07228756e-04 1.69471279e-03 -1.39096286e-04 -1.06428721e-04\n", + " 2.21667811e-04 -6.67363405e-04]\n", + " [ 2.42476597e-01 8.81621122e-01 1.15823690e-02 -1.12887248e-02\n", + " -2.11387873e-04 1.16765499e-03 4.10967134e-03 1.74771983e-03\n", + " 1.59845210e-03 -1.26217981e-03]\n", + " [ 2.55703926e-05 -8.60796776e-04 3.18645127e-03 6.16440922e-03\n", + " -2.49969959e-03 -1.05984509e-05 4.86701727e-04 -3.12706339e-04\n", + " -1.15513394e-05 -1.47292158e-04]\n", + " [ 2.55703926e-05 -8.60796776e-04 3.18645127e-03 6.16440922e-03\n", + " -2.49969959e-03 -1.05984509e-05 4.86701727e-04 -3.12706339e-04\n", + " -1.15513394e-05 -1.47292158e-04]\n", + " [ 2.55703926e-05 -8.60796776e-04 3.18645127e-03 6.16440922e-03\n", + " -2.49969959e-03 -1.05984509e-05 4.86701727e-04 -3.12706339e-04\n", + " -1.15513394e-05 -1.47292158e-04]\n", + " [ 2.20222771e-03 -1.25420187e-03 2.15841085e-03 2.34137475e-03\n", + " -1.31809153e-04 -7.01203942e-04 -6.89302571e-04 3.71206552e-05\n", + " 2.85808463e-04 4.54799854e-04]\n", + " [ 2.20222771e-03 -1.25420187e-03 2.15841085e-03 2.34137475e-03\n", + " -1.31809153e-04 -7.01203942e-04 -6.89302571e-04 3.71206552e-05\n", + " 2.85808463e-04 4.54799854e-04]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731366052.222467 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223012 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223257 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223499 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223719 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.223937 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.224165 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.224378 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.224753 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.224968 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.225186 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.225397 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.225609 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.225826 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226051 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226282 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226479 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226707 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.226926 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.227148 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.227380 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.227620 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.227856 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.228215 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.228442 378144 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.231589 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.232028 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.232355 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.232658 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.232933 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.233213 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.233526 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.233801 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.234237 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.234528 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.234826 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.235100 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.235373 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.235666 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.235963 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.236267 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.236525 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.236821 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.237118 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.237427 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.237735 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.238048 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.238371 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.238817 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731366052.239120 378122 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + } + ], + "source": [ + "# Checkpoint after tiling\n", + "tiled_images, tiled_centers = data_loader.process_data()\n", + "print(\"Tiled images shape:\", tiled_images.shape) # Expected: (num_images, num_tiles, tile_size, tile_size)\n", + "print(\"Tiled centers shape:\", tiled_centers.shape) # Expected: (num_images, num_tiles, max_hits_per_tile, 2)\n", + "\n", + "# Checkpoint after flattening\n", + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "print(\"Flattened train images shape:\", train_images_flat.shape) # Expected: (num_images * num_tiles, tile_size, tile_size, 1)\n", + "print(\"Flattened train centers shape:\", train_centers_flat.shape) # Expected: (num_images * num_tiles, max_hits_per_tile * 2)\n", + "\n", + "# Check specific samples to ensure values match expectations\n", + "print(\"Sample flattened image tile:\", train_images_flat[0].reshape(8, 8)) # Reshape to view as 8x8\n", + "print(\"Sample flattened centers:\", train_centers_flat[0]) # Should have 10 elements, representing 5 (x, y) pairs\n", + "\n", + "# Train and evaluate the model with checkpoints in place to validate output\n", + "history = model.fit(\n", + " train_dataset_flat,\n", + " validation_data=val_dataset_flat,\n", + " epochs=5, # Reduced for debugging; increase once everything is confirmed to work\n", + " batch_size=batch_size\n", + ")\n", + "\n", + "# After training, visualize a sample of predictions to validate model behavior\n", + "predictions = model.predict(val_images_flat[:10]) # Predict on a small batch\n", + "print(\"Predicted hit centers for sample validation tiles:\", predictions)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sample tiled images for the first image: [[[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 89 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " ...\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]]\n", + "Sample tiled centers for the first image: [list([]) list([(6.0, 2.0), (4.0, 1.0)]) list([]) list([])\n", + " list([(1.0, 5.0)]) list([]) list([]) list([(1.0, 4.0)])\n", + " list([(5.0, 2.0)]) list([]) list([]) list([]) list([]) list([]) list([])\n", + " list([])]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_377777/1698765166.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "# After tiling and mapping hits\n", + "tiled_images, tiled_centers = data_loader.process_data()\n", + "\n", + "# Inspect a sample image and its tiles\n", + "print(\"Sample tiled images for the first image:\", tiled_images[0])\n", + "print(\"Sample tiled centers for the first image:\", tiled_centers[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processed tiled images shape: (10000, 16, 8, 8)\n", + "Processed tiled centers shape: (10000, 16, 5, 2)\n", + "Sample tiled images for the first image: [[[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 89 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " ...\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]\n", + "\n", + " [[ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " ...\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]\n", + " [ 0 0 0 ... 0 0 0]]]\n", + "Sample tiled centers for the first image: [[[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[6. 2.]\n", + " [4. 1.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[1. 5.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[1. 4.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[5. 2.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]\n", + "\n", + " [[0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]\n", + " [0. 0.]]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " # Pad or truncate hits for each tile to ensure consistent length\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # Convert to NumPy arrays with fixed dimensions\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/20KFixed_Mixed_5_32by32_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Process the data and check the results\n", + "tiled_images, tiled_centers = data_loader.process_data()\n", + "print(\"Processed tiled images shape:\", tiled_images.shape) # Should be (num_images, num_tiles, tile_size, tile_size)\n", + "print(\"Processed tiled centers shape:\", tiled_centers.shape) # Should be (num_images, num_tiles, max_hits_per_tile, 2)\n", + "\n", + "# Visualize the first image's tiles and centers\n", + "print(\"Sample tiled images for the first image:\", tiled_images[0])\n", + "print(\"Sample tiled centers for the first image:\", tiled_centers[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " \n", + " # Normalize image data to [0, 1]\n", + " normalized_images = tiled_images / 255.0 # Assuming the pixel values are in the 0-255 range\n", + " \n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " return normalized_images, np.array(padded_centers)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + " \n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and pad if necessary\n", + " flat_centers = []\n", + " for img_centers in centers:\n", + " for tile_centers in img_centers:\n", + " # Convert tile_centers to a list of tuples to handle padding consistently\n", + " tile_centers = list(tile_centers)\n", + " if len(tile_centers) == 0:\n", + " tile_centers = [(0, 0)] * max_hits_per_tile\n", + " else:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " tile_centers = tile_centers[:max_hits_per_tile] + [(0, 0)] * (max_hits_per_tile - len(tile_centers))\n", + "\n", + " # Flatten each (x, y) hit into a single list\n", + " flat_centers.append([coord for hit in tile_centers for coord in hit])\n", + "\n", + " flat_centers = np.array(flat_centers)\n", + " return flat_images, flat_centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Flattened train images shape: (128000, 8, 8, 1)\n", + "Flattened train centers shape: (128000, 10)\n", + "Sample flattened centers after normalization: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n" + ] + } + ], + "source": [ + "train_images_flat, train_centers_flat = flatten_dataset(train_images, train_midpoints, tile_size=8, max_hits_per_tile=5)\n", + "print(\"Flattened train images shape:\", train_images_flat.shape) # Expected (128000, 8, 8, 1)\n", + "print(\"Flattened train centers shape:\", train_centers_flat.shape) # Expected (128000, 10)\n", + "print(\"Sample flattened centers after normalization:\", train_centers_flat[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 10 samples of flattened centers: [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0.125 0.75 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0.75 0.875 0. 0. 0. 0. 0. 0. 0. 0. ]\n", + " [0.25 0. 0. 0. 0. 0. 0. 0. 0. 0. ]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:10000])\n", + " centers = np.array(f['centers_training'][:10000])\n", + " \n", + " # Debug: Print the raw centers before any processing\n", + " print(\"Raw centers for first image:\", centers[0])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " # Debug: Print hits mapped to tiles for the first image\n", + " print(\"Mapped hits per tile for first image:\", hits_per_tile)\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # Debug: Check tiled centers before normalization and padding\n", + " print(\"Tiled centers for the first image before padding:\", tiled_centers[0])\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + "\n", + " def pad_hits(self, centers):\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + "\n", + " # Debug: Print padded centers for the first image\n", + " print(\"Padded centers for the first image:\", padded_centers[0])\n", + " return np.array(padded_centers)\n", + "\n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / 255.0 # Assuming image values are in 0-255\n", + "\n", + " # Normalize centers by scaling coordinates to the tile size and apply padding\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " # Debug: Check normalized and padded centers for the first image\n", + " print(\"Normalized and padded centers for the first image:\", padded_centers[0])\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + "# Instantiate DataLoader and inspect each step\n", + "file_path = '/path/to/your/h5file.h5'\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=5)\n", + "\n", + "# Run data processing and normalization\n", + "normalized_images, normalized_centers = data_loader.normalize_data()\n", + "\n", + "# Flatten the dataset and inspect the output\n", + "train_images_flat, train_centers_flat = flatten_dataset(normalized_images, normalized_centers, tile_size=8, max_hits_per_tile=5)\n", + "print(\"Sample flattened centers:\", train_centers_flat[:10])\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Electron Counting Tiling approach/64 by 64 images.ipynb b/Electron Counting Tiling approach/64 by 64 images.ipynb new file mode 100644 index 0000000..3c31671 --- /dev/null +++ b/Electron Counting Tiling approach/64 by 64 images.ipynb @@ -0,0 +1,4399 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 19:53:27.226182: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-21 19:53:27.240392: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-21 19:53:27.253355: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-21 19:53:27.257243: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-21 19:53:27.269162: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-21 19:53:27.850025: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:7', '/job:localhost/replica:0/task:0/device:GPU:8', '/job:localhost/replica:0/task:0/device:GPU:9')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 19:53:29.671403: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:c9:00.0, compute capability: 8.0\n", + "2024-11-21 19:53:29.672802: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79196 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:ce:00.0, compute capability: 8.0\n", + "2024-11-21 19:53:29.674125: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:cf:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"7,8,9\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:7\",\"/gpu:8\",\"/gpu:9\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=8, max_hits_per_tile=3):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " \n", + " # Debug: Print the raw centers before any processing\n", + " # print(\"Raw centers for first image:\", centers[0])\n", + " return images, centers\n", + "\n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + "\n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + "\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + "\n", + " local_x = x % self.tile_size\n", + " local_y = y % self.tile_size\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + "\n", + " # Debug: Print hits mapped to tiles\n", + " # print(\"Mapped hits per tile for first image:\", hits_per_tile)\n", + " return tiles, hits_per_tile\n", + "\n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + "\n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + "\n", + " tile_hits_list = [\n", + " hits_per_tile[i][:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(hits_per_tile[i]))\n", + " for i in range(len(tiles))\n", + " ]\n", + " tiled_centers.append(tile_hits_list)\n", + "\n", + " # print(\"Tiled centers before padding:\", tiled_centers[0])\n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + " def pad_hits(self, centers):\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + "\n", + " # print(\"Padded centers for first image:\", padded_centers[0])\n", + " return np.array(padded_centers)\n", + " \n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " normalized_images = tiled_images / np.max(tiled_images) \n", + "\n", + " # Normalize coordinates to be within the range [0, 1] based on tile size\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile]\n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + "\n", + " # Debugging normalized and padded centers\n", + " # print(\"Normalized and padded centers for the first image:\", padded_centers[0])\n", + " return normalized_images, np.array(padded_centers)\n", + "\n", + "\n", + " \n", + " def reconstruct_image_from_tiles(self, tiles, tile_size, num_tiles_per_row=None):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, array of tiles with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles).\n", + " - num_tiles_per_row: int, the number of tiles per row/column in the original image grid.\n", + " If None, it defaults to sqrt of the number of tiles (assuming a square layout).\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " # If num_tiles_per_row is not provided, calculate it as the square root of the number of tiles\n", + " if num_tiles_per_row is None:\n", + " num_tiles_per_row = int(np.sqrt(len(tiles)))\n", + " \n", + " # Initialize an empty array for the reconstructed image\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " \n", + " # Place each tile in the correct position in the reconstructed image\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " \n", + " return reconstructed_image\n", + " \n", + "def flatten_dataset(images, centers, tile_size, max_hits_per_tile):\n", + " \"\"\"\n", + " Flattens the dataset to treat each tile as an independent example.\n", + " \n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (e.g., 8 for 8x8 tiles)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile\n", + "\n", + " Returns:\n", + " - flat_images: np.array, reshaped images with shape (num_images * num_tiles, tile_size, tile_size, 1)\n", + " - flat_centers: np.array, reshaped hit locations with shape (num_images * num_tiles, max_hits_per_tile * 2)\n", + " \"\"\"\n", + " # Reshape images\n", + " num_images, num_tiles, _, _ = images.shape\n", + " flat_images = images.reshape(-1, tile_size, tile_size, 1)\n", + "\n", + " # Ensure centers have the right shape and pad if necessary\n", + " flat_centers = []\n", + " for img_centers in centers:\n", + " for tile_centers in img_centers:\n", + " # Convert tile_centers to a list of tuples to handle padding consistently\n", + " tile_centers = list(tile_centers)\n", + " if len(tile_centers) == 0:\n", + " tile_centers = [(0, 0)] * max_hits_per_tile\n", + " else:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " tile_centers = tile_centers[:max_hits_per_tile] + [(0, 0)] * (max_hits_per_tile - len(tile_centers))\n", + "\n", + " # Flatten each (x, y) hit into a single list\n", + " flat_centers.append([coord for hit in tile_centers for coord in hit])\n", + "\n", + " flat_centers = np.array(flat_centers)\n", + " return flat_images, flat_centers\n", + "\n", + "\n", + "# Split data into training and validation sets\n", + "def create_datasets(data_loader, train_size=0.8):\n", + " # Normalize and flatten data from data loader\n", + " normalized_images, normalized_centers = data_loader.normalize_data()\n", + " train_images, val_images, train_centers, val_centers = train_test_split(\n", + " normalized_images, normalized_centers, train_size=train_size, random_state=42\n", + " )\n", + "\n", + " # Flatten the dataset\n", + " train_images_flat, train_centers_flat = flatten_dataset(train_images, train_centers, tile_size=8, max_hits_per_tile=3)\n", + " val_images_flat, val_centers_flat = flatten_dataset(val_images, val_centers, tile_size=8, max_hits_per_tile=3)\n", + "\n", + " # Create TensorFlow datasets for training and validation\n", + " batch_size = 4000\n", + " train_dataset = tf.data.Dataset.from_tensor_slices((train_images_flat, train_centers_flat)).batch(batch_size)\n", + " val_dataset = tf.data.Dataset.from_tensor_slices((val_images_flat, val_centers_flat)).batch(batch_size)\n", + "\n", + " return train_dataset, val_dataset, train_images, val_images, train_centers, val_centers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_100_256by256_Randomindex.h5' ###for training\n", + "# file_path ='/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5' ###for testing\n", + "data_loader = DataLoader(file_path, tile_size=8, max_hits_per_tile=3)\n", + "\n", + "# images, centers = data_loader.normalize_data()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10000, 1024, 5, 2)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create Datasets for Training/Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Generate the datasets\n", + "train_dataset, val_dataset, train_images, val_images, train_centers, val_centers = create_datasets(data_loader)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((8000, 1024, 8, 8),\n", + " (2000, 1024, 8, 8),\n", + " (8000, 1024, 3, 2),\n", + " (2000, 1024, 3, 2))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape, val_images.shape, train_centers.shape, val_centers.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize sample tiles from the dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def visualize_image_with_tiles(data_loader, image_index=0):\n", + " \"\"\"\n", + " Visualizes the original image with a tile grid and overlays hit locations.\n", + "\n", + " Parameters:\n", + " - data_loader: Instance of DataLoader containing images and centers.\n", + " - image_index: Index of the image to visualize.\n", + " \"\"\"\n", + " image = data_loader.images[image_index]\n", + " centers = data_loader.centers[image_index]\n", + " \n", + " # Plot the original image\n", + " plt.figure(figsize=(12, 12))\n", + " plt.imshow(image, cmap='gray')\n", + " \n", + " # Overlay tile grid\n", + " tile_size = data_loader.tile_size\n", + " num_tiles_row = image.shape[0] // tile_size\n", + " num_tiles_col = image.shape[1] // tile_size\n", + " \n", + " for i in range(1, num_tiles_row):\n", + " plt.axhline(i * tile_size, color='red', linewidth=0.5)\n", + " for j in range(1, num_tiles_col):\n", + " plt.axvline(j * tile_size, color='red', linewidth=0.5)\n", + " \n", + " # Plot centers\n", + " for hit in centers:\n", + " _, x, y = hit\n", + " plt.plot(x, y, 'bo', markersize=2)\n", + " \n", + " plt.title(f'Original Image with Tiles and Hit Locations (Image {image_index})')\n", + " plt.axis('on')\n", + " plt.show()\n", + "\n", + "z=np.random.randint(0,1000)\n", + "visualize_image_with_tiles(data_loader, image_index=z)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternate way of visualizing sample tiles from Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABhYAAAXCCAYAAAD3ltfmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1hT1+MG8DfsISIiIrhxz7rFvXBvax1V66COulu31j3qqFbraF217rpnv9WqdYJ7b7TuhSgKKijr/P7wl5SQAPdCSE7a9/M8Pi03Nzcvh3BfkpN7r0YIIUBERERERERERERERKSAjaUDEBERERERERERERGR9eDEAhERERERERERERERKcaJBSIiIiIiIiIiIiIiUowTC0REREREREREREREpBgnFoiIiIiIiIiIiIiISDFOLBARERERERERERERkWKcWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIpxYoGIiIiIiIiIiIiIiBTjxAIRERH9KwghsGHDBrRp0wa5c+eGk5MTPDw8UKZMGQwfPhwPHjxI1/bv3bsHjUaDfPnymSYwgNq1a0Oj0eDQoUMm26a5cvz6668mHw8yL41GA41Go2jdfPny6dZX+k/73OjWrRs0Gg1+/fVXvW1qn0PdunUz7TcmkQkTJkCj0WDChAmq75vcuKXHoUOHFP3ctfs7jUaDe/fuZXiupB4+fIhvv/0W/v7+8PLygr29PbJkyYJy5cph0KBBOH36dIY9NhEREREpY2fpAERERETp9eTJE7Ru3RqnTp2CRqNB+fLlUa1aNURFReH48eOYNWsWfvzxR8yePRv9+vWzdFwiq9O2bVu8ePFCb9nbt2+xZcsWAMCnn36KTJky6d2eLVs2s+WzNocOHUKdOnVQq1Yti08smsqvv/6K7t27o2vXrumadJg5cybGjh2LmJgYZMqUCZUrV0b27Nnx5s0bXL58GT/++CN+/PFHDBs2DDNnzjTdN6DCv/HnR0RERKQWJxaIiIjIqr169Qo1atTAnTt3ULZsWaxevRolSpTQ3R4XF4d58+ZhxIgR6N+/P+Lj4zFw4EDVj5MzZ05cv34d9vb2Jsu+atUqREVFIU+ePCbbJlFG+P777w2W3bt3Tzex8P333yd79Mp3332HkSNHwsfHJyMjSql///7o0KHDv2qSJSN/niNHjsSMGTNgb2+P77//Hv3794ejo6PeOidOnMCYMWMQEhJi8scnIiIiIuU4sUBERERWrX///rhz5w7y58+Pv/76C1myZNG73c7ODkOGDIGTkxP69++PoUOHon79+ihWrJiqx7G3t0fRokVNmBycUKD/BB8fn//kpALw8aiNf9OkApBxP88DBw5gxowZAIANGzagdevWRtfz9/fH/v37cezYMZNnICIiIiLleI0FIiIislp37tzBb7/9BuDjJ6aTTiok1rdvX3zyySeIjY01OH1G4vOgP3jwAIGBgcidOzfs7e11539P7RoLV65cwaeffops2bLBxcUFpUqVwty5c5GQkKA7P33Sc5Und22DxOcwv3v3Lrp06YIcOXLA0dERBQoUwLfffosPHz4YZHjz5g2WLl2KNm3aoFChQnB1dYWrqytKlSqFMWPG4PXr1ykNp8kkPof7mjVrUKlSJWTKlAleXl7o2LGj7noXQggsWLAAZcqUgaurK7Jly4Zu3brh+fPnBtuMjY3FmjVr0KlTJxQtWhSZM2eGs7MzihQpgoEDB+LJkyfJ5nn58iUGDhyIPHnywNHREXnz5sXgwYPx+vXrVM8Xf+DAAbRp0wY+Pj5wcHBA9uzZ0bp1axw/flz1uFy7dg3jx49HtWrVkDNnTjg4OMDT0xMBAQHYuHGj0ftoz4lfu3ZtxMbGYsaMGShRogScnZ3h6emJNm3a4Pr168k+5vHjx9G4cWNkyZIFmTJlQoUKFfDLL7+ozp4eaT0n/5MnT/DNN9+gWLFicHFxgZubGypWrIgFCxYgLi7OYP0PHz5g1qxZKF++PNzc3ODg4IAcOXKgYsWKGD58OMLDwxU9brly5aDRaHDu3Dm95c+fP4eNjQ00Gg2GDx9ucL+6detCo9Hgr7/+0i0zdo2F2rVro06dOgCAw4cPG70uRVJq9gMZzdjPM1++fOjevTsAYOXKlXrfU+3atRVtd8qUKQCAFi1aJDupoKXRaFCjRg2D5a9evcL48eNRpkwZuLm56fbFU6ZMQVRUlMH6iX8+YWFh6NevH3Lnzg0HBwfkzp0bAwYMMNhvqv35qd2HJN5/rlixAlWqVIG7u7teh0RERODbb79FqVKl4OrqCkdHR/j6+qJatWoYN24cYmNjUxw/IiIiIlPgEQtERERktXbt2oWEhARkyZIFLVq0SHFdjUaDLl264OLFi9i1axeEEAYXML116xbKli0LBwcHVKtWDUIIRZ82Pnz4MBo3bozo6GgUKFAA9evXx8uXLzFixAicOHEizd/fhQsXMGjQIHh4eKBWrVoIDw9HUFAQpk6diqtXr2Lbtm1661+8eBG9evWCl5cXihQpgvLly+PVq1c4e/Yspk2bho0bN+LEiRPw9PRMcyY1Ro0ahe+//x41a9ZE48aNcerUKfz2228ICgrCxYsX0adPH+zcuRO1a9eGn58fgoKCsHLlSpw/fx6nT5+Gg4ODbluhoaHo0qUL3N3dUaxYMZQuXRrv3r3DhQsXMH/+fPz2228IDg5GwYIF9TI8ffoUNWrUwN9//42sWbOiWbNmSEhIwKpVq7Bnz54Uj1wZOnQoZs+eDRsbG1SoUAE1atTAgwcPsGPHDuzatQtLly7VvZmqxJw5c7B8+XIULVoUpUqVQpYsWfDgwQMcPHgQBw4cwIkTJzBnzhyj942NjUWTJk0QHByMmjVrolixYjh16hS2bduGgwcP4vz58wZvam7atAkdO3ZEfHw8SpYsiVKlSuHhw4f48ssvcfXqVcW5LeHIkSNo1aoVXr16hXz58qF+/fr48OEDTp06hQEDBmDXrl3YvXu37tRkCQkJaNq0KQ4cOIDMmTOjRo0ayJIlC8LCwnDr1i3MmjULn3/+ObJmzZrqYwcEBOD8+fPYv38/ypUrp1u+f/9+CCF0/59YdHQ0goOD4ezsjGrVqqW4/UaNGsHJyQl79+6Ft7c3GjVqpLvN2P5G7X7AEtq2bYsTJ04gKCgIBQoUQPXq1XW3KTnS6/Xr1zhy5AgAoGvXrmnKcO3aNTRq1AgPHz6Ej48PqlevDnt7e5w6dQpjx47Fli1bcOjQIbi7uxvc9+HDhyhXrhxiY2NRrVo1vH//HkFBQViwYAFOnjyJoKAg3XNNzc8vPfuQAQMGYNGiRahatSqaNm2KO3fuQKPRICoqCtWrV8eVK1fg5eWFevXqwdXVFc+ePcONGzcQHByMb775JsWJdiIiIiKTEERERERWqkuXLgKAqFOnjqL1Dx8+LAAIAOLOnTu65ePHj9ct79y5s3j//r3Bfe/evSsAiLx58+otj4qKEjlz5hQAxJAhQ0R8fLzutqtXrwpvb2/dtu/evat331q1agkA4uDBg3rLu3btqrvPmDFjRFxcnO62y5cvC1dXVwFABAcH693v4cOHYv/+/XoZhBDi3bt34osvvhAARN++fQ2+t+RypGTFihVGx0MIocvu6ekpLly4oFseFRUlqlevLgCIUqVKiQIFCoh79+7pbg8LCxMFCxYUAMSaNWv0thkZGSl27NghPnz4oLc8JiZGjBo1SgAQTZo0McjSunVrAUDUrl1bRERE6Ja/evVKlwWAWLFihd79lixZIgCIggULiosXL+rddvjwYeHm5iYcHBxESEhIqmOldejQIfH3338bLL9x44bIlSuXACBOnjypd9vBgwd1GcuWLSuePn2quy06Olo0bNhQABC9evXSu9/Tp0+Fm5ubACDmzJmjd9v+/fuFk5OTbrtppf2dMPbcTkz7fE46xtrnUNeuXQ2ye3p6Co1GIxYtWqT3fH7x4oWoW7euACAmTpyoW6793S5btqyIjIw0yHD69Gnx4sULRd/X3r17BQBRv359veXdu3cXAETp0qWFRqMRYWFhqd5Hu28ZP3683nLtz7VWrVrJ5kjrfiAliZ9PKUnpZ6v256nEgQMHdI/34MED1fePiooSBQoUEADEt99+q7efePfunejYsaMAILp37653v8T7/m7duunt+x88eKDbt69bt07vfkp+fmndh2jzZM6cWRw/ftxguytXrhQAROPGjUVMTIzebfHx8eLQoUMG+0kiIiKijMBTIREREZHVCgsLAwB4e3srWj/xetr7JpY1a1YsWLDA4GKhKdm8eTMeP36MvHnz4rvvvoONzT9/XhUvXhxjx45VvK2kypcvj8mTJ8PW1la3rGTJkujSpQsAw09N58qVC/Xq1dPLAAAuLi746aefYGdnh02bNqU5j1qTJk3CJ598ovva2dkZ33zzDQDg8uXL+PHHH5E3b17d7dmyZcNXX30F4OPpQxJzc3NDixYt9I5iAD5e+2LatGnw9fXFnj178ObNG91t9+/fx/bt22FjY4OffvoJmTNn1t2WJUsW/PTTTwZHrQAfP/2uPXXNb7/9htKlS+vdXrNmTYwdOxYxMTFYvHix4vGoVasW/Pz8DJYXKVJE9zzZvHmz0ftqNBqsWLECOXLk0C1zcnLCxIkTARg+F5YvX443b97A398fX3/9td5t9erVQ+/evRXnNre5c+fi5cuX6NevH7766iu957OnpydWrVoFe3t7LFiwQHcEQWhoKACgRo0acHNzM9hmhQoVFB+pU6NGDTg6OuLYsWN6pxo6cOAA8ubNi969e0MIofcc1Y5/QECA+m84FWr3A0olPoVP0n/58+c3SXalEu+Ps2fPrvr+K1euxN9//41mzZph8uTJevsJFxcXLFmyBNmzZ8fq1avx6tUrg/vnypULCxcu1Nv3a0+FBKgfY1PsQ4YOHQp/f3+D5drnev369XVHUWjZ2NigVq1aBvtJIiIioozAUyERERHRf4b2TcjkBAQEGD1NRkoOHz4MAPjss88M3uQBgE6dOqF///6qtqnVrFkzo298a0/f8/jxY6P3Cw4OxtGjR/HgwQNERUXpvm8HBweEhYXh1atX8PDwSFMmNZo0aWKwrFChQgA+XlS7QYMGyd6e3DUTLl68iAMHDuDu3bt49+4dEhISAABxcXFISEjA7du3UbZsWQDA0aNHIYRA+fLljZ6OpWTJkihdujQuXryot/z8+fN48uQJChQogPLlyxvNoT1vfHBwsNHbk/P27Vv88ccfOH/+PF68eIGYmBgAH0/ZBAA3b940er88efLoTdJoJfdc0F63o1OnTka317VrV8ybN09VdnP5/fffAQDt27c3envOnDlRqFAhXLt2Dbdu3ULhwoVRrlw52Nra4pdffkHhwoV157RPC2dnZ1StWhUHDx7EsWPHUK9ePYSEhODBgwf48ssvdZMH+/fv12XMyImFtO4HUpPSKYfevn2LLVu2pGm7lpDac0Z7fZH//e9/OH36tMG+p169enBxcTG4X1rH2BT7kLZt2xpdXrFiRQDAzJkz4enpiWbNmik6xRcRERGRqXFigYiIiKyW9nzW2k9wpibxRYG9vLwMbk/uwqkpefToUYr3zZIlC9zd3REREaF623ny5DG6XPvJ+/fv3+stf/78OT799FMcO3Ysxe1GRkaaZWLBWP5MmTIBAHx8fGBnZ/inqPbT5km/t3fv3qFLly6pnk8+MjJS9/+p/Wy0tyWdWLhz5w4A4O+//zb6hm5ixo58Sc6uXbvQvXt3vHz5Mtl1EudPLLXnQtKL+Gq/9+Q+eW7uT6SroR1/YxfnTSosLAyFCxdGgQIF8MMPP2DYsGHo378/+vfvj7x586JKlSpo1qwZPvvsM1Wf4g4ICMDBgwexf/9+1KtXTzdxUL9+fRQuXBi5c+fWLXv58iUuXLgAT09P3aSWKandDyiV0sW07927Z9aJhcT74+fPnyN37tyq7q99znTp0kV3JEdyjP3OmnqMTbEPSW6/Vbt2bYwYMQKzZs1C165dodFoUKhQIVSrVg0tW7ZE8+bNDY5aIyIiIsoInFggIiIiq1W+fHmsWbMG586dQ1xcnNE3qhM7deoUgI+nUzH2po2zs3Oas6T05lFqbywlR+2bQ19++SWOHTuGKlWqYOLEifjkk0/g4eGhO5LC19cXT58+TfXIDVNJKb/a723UqFHYtm0bihYtiunTp6NixYrIli2b7s3iqlWr4vjx40a/N7U/G+1REDly5EDDhg1TzKXk4t7Ax088t2/fHtHR0Rg+fDg6deqEfPnyIVOmTLCxscGff/6Jhg0bJvuz+S+9Uagd/7Zt28LV1TXFdROf3mjAgAFo164ddu7ciWPHjuHYsWP47bff8Ntvv2H8+PE4evSo4qMYAgICMGbMGOzbtw/fffcd9u/fDxsbG9SrV093+4oVK3D79m2cO3cOQgjUrVs3zb/rKfkv/OzLli0LGxsbJCQk4PTp06onFrTPmUaNGqV6arzEp1/TMvUYm2IfklIfTZ8+HX369MGuXbtw7NgxBAUFYcWKFVixYgUqVqyIgwcPpvq7Q0RERJRenFggIiIiq9W8eXMMGTIEERER2LFjBz799NNk1xVCYPXq1QCSP7VIWuTMmRPAx0/4GhMREYHXr1+b5LFS8u7dO/zvf/+DjY0N/ve//yFLliwGtz979izDc2SUjRs3AgA2bNhgcL5yALh165bBstR+Nsndpn1T09PTM8VPdauxa9cuREdHo3Xr1pgxY4bB7cbyp0fOnDlx48aNZL/3lMbE0nLnzo1bt25hxIgRqFChgqr7ent7o2fPnujZsycA4MaNG+jRoweOHz+OkSNHYuXKlYq2U6FCBWTJkgXnz59HWFgYDh48iDJlyugmMrQTC/v378e5c+d0yyhtPDw8UKNGDRw+fBgrV65EmzZtVN0/d+7cuHHjBgIDA5M9hZA5ZcQ+JKl8+fJhwIABuutAnD59Gp07d8bp06cxc+ZM3fVXiIiIiDLKv//jL0RERPSvVaBAAbRr1w4AMGzYsBTfwF+0aBEuXboEOzs7DBs2zGQZatasCQDYtGkT4uLiDG5ft26dyR4rJREREYiPj0fmzJkNJhUAYM2aNWY7UiEjhIeHAzD+aeO9e/fixYsXBstr1KgBjUaDs2fPIiQkxOD2a9euGZwGCYDuaIhr167h6tWrJkifcn4hhMmfJ7Vq1QIArF271ujtq1atMunjmVLjxo0B/DOZlB5FixbFiBEjAAAXLlxQfD8bGxvUqVMHCQkJmDlzJl6/fo369evrbq9Xrx40Gg327duXpusraI+0MbbPsFbp/Z7GjBkDANi5c2eqpzwTQuid8s2UzxklUvteM2IfkpqKFSuib9++ANQ914mIiIjSihMLREREZNUWLlyIfPny4e7du6hbt67BmzhxcXGYM2cOBg0aBACYMWMGSpQoYbLH/+yzz+Dj44N79+5hzJgxulNgAB8/LT1p0iSTPVZKvL294eHhgdevX+uOzNA6ceIERo0aZZYcGUV7EdX58+frLb958yb69Olj9D758uVD8+bNkZCQgK+++gpv3rzR3RYREYGvvvrK6GSLvb09xo8fDyEEWrdubfSaFfHx8fjrr79w4sQJVfk3b96su1Czdjvjxo1TfRHo1AQGBiJTpkw4fvw4fvzxR73bDh06hJ9//tmkj2dKw4YNQ5YsWTBnzhzMnj1bd4HrxO7evYs1a9bovv7rr7/wv//9D7GxsXrrCSGwe/duAMYndVKinShYsGABAOhNLHh7e6NkyZL43//+h7t37yJ//vzw8/NTvO1cuXIB+HikStLM1kr7PV27di1N969fvz6GDBkCAOjQoQPmzJljcO0QADh79iwaNmyI77//XresV69eyJs3LzZt2oQRI0bo/a5rPXv2DEuXLk1TtqRS+/llxD5Ea9u2bThy5Ihe1wBAbGws9uzZA0D9c52IiIgoLXgqJCIiIrJqWbNmxbFjx9CqVSucOXMGpUqVQoUKFVCgQAFERUXh+PHjCAsLg4ODA2bPnq2bYDAVFxcXrFmzBk2bNsXMmTOxdetWVKhQAeHh4Th06BBatmyJkydP4sGDB6ouHquWra0txo0bh6+//hpffPEFFi5cCD8/Pzx48ADBwcHo3Lkzjhw5gvv372dYhow0fvx4tG3bFmPHjsXGjRtRokQJPH/+HEePHkWNGjXg6+tr9M35n376CZcuXcJff/2F/Pnzo1atWhBC4PDhw/D09ESLFi2wc+dOg59N//798eDBA8yaNQs1atRAiRIlULBgQTg7O+PZs2e4cOECXr9+jZ9++gn+/v6p5m/evDnKly+Ps2fPonDhwqhVqxZcXV1x8uRJPHnyBCNGjDB6iqS08vX1xdKlS9G5c2cMGjQIy5YtQ8mSJfH48WMcPXoUgwcPxg8//GCyxzOlXLly6U5tNnToUMycORMlS5aEj48PIiIicP36dfz999+oXLkyOnfuDAC4dOkSvv76a2TOnBnlypWDr68voqOjce7cOdy/fx/u7u6qJ/m0Ewvv37+Hs7MzqlevbnD75cuX9dZVKk+ePKhQoYLePsvJyQnZsmXD9OnTVW1LFv7+/vD19cX58+dRrlw5lCpVCvb29ihSpIjio8S+//57ZM2aFRMmTMCQIUMwYcIEVK5cGdmzZ8fbt29x6dIl3Wm8tEeiAICrqyt+//13NGvWDDNnzsSSJUtQunRp5MqVC1FRUQgJCcH169eRPXt23Wmy0kPJz8/U+xCtw4cPY968eciWLRvKli2L7Nmz482bNzhx4gSeP3+OnDlzYvjw4en+HomIiIhSwyMWiIiIyOrlzJkTJ0+exPr169GiRQs8fvwYW7duxaFDh5AjRw4MGTIEN2/eNPmkglbdunVx8uRJtG7dGuHh4di+fTsePXqEqVOnYs2aNXj27BlsbGyQNWvWDHl8rcGDB2P79u2oWrUqbt68iV27duHDhw9YuHCh4nPLy6pNmzY4fPgw6tWrh6dPn2Lnzp14/vw5JkyYgD/++EN3geqkfH19cerUKfTr1w/Ozs7YvXs3zpw5g44dO+LEiRN4+/YtAOMXUJ05cyaCgoLQqVMnvH37Fnv27MHvv/+OJ0+eoHbt2li2bBnat2+vKL+dnR0OHTqE0aNHI2fOnDhw4AAOHTqEsmXL4vjx42jUqFHaBycZHTp0wKFDh9CwYUPcv38fO3bswJs3b/Dzzz9jzpw5Jn88U6pZsyauXr2KsWPHIleuXDh9+jQ2bdqECxcuwNvbG+PHj9f79Hnz5s0xYcIEVKxYEXfu3NH9/ru7u2PkyJG4cuUKypQpoypD4cKFdefKr169OhwdHfVuTzyZkJbrK2zZsgWff/45IiMjsWHDBixfvhy//fab6u3IwsHBAXv37kWLFi3w6NEjrFmzBsuXL8fvv/+uajujR4/GrVu3MGrUKBQtWhTnz5/Hxo0bcfjwYXh4eGDQoEE4d+6cwQRMiRIlcOnSJcycORPFihXDpUuXsGnTJpw8eRKurq4YOnRoqqdYUkPJz8+U+xCtbt26YeTIkShatCiuXbuGTZs24fjx48idOzemTZuGixcv6o6oICIiIspIGmHNJ9slIiIiktyRI0dQq1YtlCpVCpcuXbJ0HErk9evX8PPzQ0REBEJDQ41OLhAREREREZEhHrFARERElE5hYWG4e/euwfIrV67oTrvRvXt3c8ei/3fq1CmDZWFhYejatStevXqFZs2acVKBiIiIiIhIBR6xQERERJROhw4dQp06dVC8eHH4+fnB2dkZd+/exblz55CQkID69evjf//7H+zseHkrS9BoNMiVKxeKFSsGT09PPH78GOfPn8fbt2+RJ08eHDt2THfKGyIiIiIiIkodJxaIiIiI0unJkyeYNm0aDh8+jMePH+PNmzdwc3NDiRIl8Pnnn6Nnz56cVLCgsWPH4sCBA/j777/x6tUrODg4oECBAmjWrBm++eYbeHp6WjoiERERERGRVeHEAhERERERERERERERKcZrLBARERERERERERERkWKcWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIpxYoGIiIiIiIiIiIiIiBTjxAIRERERERERERERESnGiQUiIiIiIiIiIiIiIlKMEwtERERERERERERERKQYJxaIiIiIiIiIiIiIiEgxTiwQEREREREREREREZFinFggIiIiIiIiIiIiIiLFOLFARERERERERERERESKcWKBiIiIiIiIiIiIiIgU48QCEREREREREREREREpxokFIiIiIiIiIiIiIiJSjBMLRERERERERERERESkGCcWiIiIiIiIiIiIiIhIMU4sEBERERERERERERGRYpxYICIiIiIiIiIiIiIixTixQEREREREREREREREinFigYiIiIiIiIiIiIiIFOPEAhERERERERERERERKcaJBSIiIiIiIiIiIiIiUowTC0REREREREREREREpBgnFoiIiIiIiIiIiIiISDFOLBARERERERERERERkWKcWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIpxYoGIiIiIiIiIiIiIiBTjxAIRERERERERERERESnGiQUiIiIiIiIiIiIiIlKMEwtERERERERERERERKQYJxaIiIiIiIiIiIiIiEgxTiwQEREREREREREREZFinFggIiIiIiIiIiIiIiLFOLFARERERERERERERESKcWKBiIiIiIiIiIiIiIgU48QCEREREREREREREREpxokFIiIiIiIiIiIiIiJSjBMLRERERERERERERESkGCcWiIiIiIiIiIiIiIhIMU4sEBERERERERERERGRYpxYICIiIiIiIiIiIiIixTixQEREREREREREREREinFigYiIiIiIiIiIiIiIFOPEAhERERERERERERERKcaJBSIiIiIiIiIiIiIiUowTC0REREREREREREREpBgnFoiIiIiIiIiIiIiISDFOLBARERERERERERERkWKcWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIpxYoGIiIiIiIiIiIiIiBTjxAIRERERERERERERESnGiQUiIiIiIiIiIiIiIlKMEwtERERERERERERERKQYJxaIiIiIiIiIiIiIiEgxTiwQEREREREREREREZFinFggIiIiIiIiIiIiIiLFOLFARERERERERERERESKcWKBiIiIiIiIiIiIiIgU48QCEREREREREREREREpxokFIiIiIiIiIiIiIiJSjBMLRERERERERERERESkGCcWiIiIiIiIiIiIiIhIMU4sEBERERERERERERGRYpxYICIiIiIiIiIiIiIixTixQEREREREREREREREinFigYiIiIiIiIiIiIiIFOPEAhERERERERERERERKcaJBSIiIiIiIiIiIiIiUowTC0REREREREREREREpBgnFoiIiIiIiIiIiIiISDFOLBARERERERERERERkWKcWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIpxYoGIiIiIiIiIiIiIiBTjxAIRERERERERERERESlm0YmFCRMmQKPRpOm+v/76KzQaDe7du2faUIncu3cPGo0Gv/76a4Y9BhERERERERERERGRNUnTxMLVq1fRuXNn5MyZE46OjvD19UWnTp1w9epVU+ezCocOHYJGo8HmzZstHYWIiIiIiIiIiIiIKEOpnljYunUrypUrhwMHDqB79+5YtGgRAgMDcfDgQZQrVw7btm1TvK1vv/0W0dHRaiMAALp06YLo6GjkzZs3TfcnIiIiIiIiIiIiIiL17NSs/Pfff6NLly7w8/PDkSNH4OXlpbtt0KBBqFGjBrp06YJLly7Bz88v2e28e/cOrq6usLOzg52dqgg6tra2sLW1TdN9iYiIiIiIiIiIiIgobVQdsTBr1ixERUVhyZIlepMKAJAtWzYsXrwY7969w8yZM3XLtddRuHbtGj7//HN4eHigevXqerclFh0djYEDByJbtmxwc3NDixYt8PjxY2g0GkyYMEG3nrFrLOTLlw/NmjXDsWPHUKlSJTg5OcHPzw+rVq3Se4zw8HAMHToUpUqVQqZMmZA5c2Y0btwYFy9eVDMcKdJ+byEhIejcuTPc3d3h5eWFsWPHQgiBhw8fomXLlsicOTNy5MiB2bNn690/JiYG48aNQ/ny5eHu7g5XV1fUqFEDBw8eNHisly9fokuXLsicOTOyZMmCrl274uLFi0avD3Hjxg20bdsWWbNmhZOTEypUqICdO3ea7PsmIiIiIiIiIiIion83VRMLu3btQr58+VCjRg2jt9esWRP58uXD77//bnDbZ599hqioKEybNg09e/ZM9jG6deuG+fPno0mTJpgxYwacnZ3RtGlTxRlv376Ntm3bon79+pg9ezY8PDzQrVs3ves/3LlzB9u3b0ezZs0wZ84cDBs2DJcvX0atWrXw5MkTxY+lRPv27ZGQkIDp06ejcuXKmDJlCubOnYv69esjZ86cmDFjBgoWLIihQ4fiyJEjuvtFRkZi2bJlqF27NmbMmIEJEyYgLCwMDRs2xIULF3TrJSQkoHnz5li/fj26du2KqVOn4unTp+jatatBlqtXr8Lf3x/Xr1/HyJEjMXv2bLi6uqJVq1aqTmFFRERERERERERERP9dis9DFBERgSdPnqBly5Yprle6dGns3LkTb968gZubm275J598gnXr1qV433PnzmHjxo0YPHgwfvjhBwBA37590b17d8VHE9y8eRNHjhzRTX60a9cOuXPnxooVK/D9998DAEqVKoWQkBDY2Pwzr9KlSxcULVoUy5cvx9ixYxU9lhKVKlXC4sWLAQC9evVCvnz5MGTIEHz33XcYMWIEAKBjx47w9fXFL7/8gpo1awIAPDw8cO/ePTg4OOi21bNnTxQtWhTz58/H8uXLAQDbt2/H8ePHMXfuXAwaNAgA8NVXX6F+/foGWQYNGoQ8efLg9OnTcHR0BPBxfKtXr44RI0agdevWJvu+iYiIiIiIiIiIiOjfSfERC2/evAEAvckCY7S3R0ZG6i3v06dPqo+xZ88eAB/f7E5swIABSmOiePHiekdUeHl5oUiRIrhz545umaOjo25SIT4+Hi9fvkSmTJlQpEgRnDt3TvFjKfHll1/q/t/W1hYVKlSAEAKBgYG65VmyZDHIaGtrq5tUSEhIQHh4OOLi4lChQgW9jHv27IG9vb3eUSA2Njbo16+fXo7w8HD89ddfaNeuHd68eYMXL17gxYsXePnyJRo2bIhbt27h8ePHJv3eiYiIiIiIiIiIiOjfR/ERC9oJA+0EQ3KSm4DInz9/qo9x//592NjYGKxbsGBBpTGRJ08eg2UeHh549eqV7uuEhATMmzcPixYtwt27dxEfH6+7zdPTU/FjpSWPu7s7nJyckC1bNoPlL1++1Fu2cuVKzJ49Gzdu3EBsbKxueeLxuX//Pnx8fODi4qJ336Rjdvv2bQghMHbs2GSPyHj+/Dly5syp/JsjIiIiIiIiIiIiov8cxRML7u7u8PHxwaVLl1Jc79KlS8iZMycyZ86st9zZ2TltCVWytbU1ulwIofv/adOmYezYsejRowcmT56MrFmzwsbGBoMHD0ZCQkKG51GScc2aNejWrRtatWqFYcOGIXv27LC1tcV3332Hv//+W3UO7fc1dOhQNGzY0Og6aiZwiIiIiIiIiIiIiOi/SfHEAgA0a9YMS5cuxbFjx1C9enWD248ePYp79+6hd+/eaQqTN29eJCQk4O7duyhUqJBu+e3bt9O0veRs3rwZderU0V2nQOv169cGRxJYyubNm+Hn54etW7dCo9Holo8fP15vvbx58+LgwYOIiorSO2oh6Zj5+fkBAOzt7REQEJCByYmIiIiIiIiIiIjo30zxNRYAYNiwYXB2dkbv3r0NTtsTHh6OPn36wMXFBcOGDUtTGO0n6RctWqS3fP78+WnaXnJsbW31jg4AgE2bNkl1jQHtUQ2Jc548eRLHjx/XW69hw4aIjY3F0qVLdcsSEhKwcOFCvfWyZ8+O2rVrY/HixXj69KnB44WFhZkyPhERERERERERERH9S6k6YqFQoUJYuXIlOnXqhFKlSiEwMBD58+fHvXv3sHz5crx48QLr169HgQIF0hSmfPny+PTTTzF37ly8fPkS/v7+OHz4MEJCQgBA75P76dGsWTNMmjQJ3bt3R9WqVXH58mWsXbtW96l+GTRr1gxbt25F69at0bRpU9y9exc///wzihcvjrdv3+rWa9WqFSpVqoQhQ4bg9u3bKFq0KHbu3Inw8HAA+mO2cOFCVK9eHaVKlULPnj3h5+eH0NBQHD9+HI8ePcLFixfN/n0SERERERERERERkXVRNbEAAJ999hmKFi2K7777TjeZ4OnpiTp16mD06NEoWbJkugKtWrUKOXLkwPr167Ft2zYEBARgw4YNKFKkCJycnNK1ba3Ro0fj3bt3WLduHTZs2IBy5crh999/x8iRI02yfVPo1q0bnj17hsWLF2Pv3r0oXrw41qxZg02bNuHQoUO69WxtbfH7779j0KBBWLlyJWxsbNC6dWuMHz8e1apV0xuz4sWL48yZM5g4cSJ+/fVXvHz5EtmzZ0fZsmUxbtw4C3yXRERERERERERERGRtNCLpOYEkdOHCBZQtWxZr1qxBp06dLB3HKmzfvh2tW7fGsWPHUK1aNUvHISIiIiIiIiIiIqJ/CVXXWDCH6Ohog2Vz586FjY0NatasaYFE8ks6ZvHx8Zg/fz4yZ86McuXKWSgVEREREREREREREf0bqT4VUkabOXMmzp49izp16sDOzg5//PEH/vjjD/Tq1Qu5c+e2dDwpDRgwANHR0ahSpQo+fPiArVu3Ijg4GNOmTYOzs7Ol4xERERERERERERHRv4h0p0Lat28fJk6ciGvXruHt27fIkycPunTpgjFjxsDOTrp5ECmsW7cOs2fPxu3bt/H+/XsULFgQX331Ffr372/paERERERERERERET0LyPdxAIREREREREREREREclLumssEBERERERERERERGRvDixQEREREREREREREREivGiBUlpNMnfxrNGEREREREREREREdF/HI9YICIiIiIiIiIiIiIixTixQEREREREREREREREinFigYiIiIiIiIiIiIiIFOPEAhERERERERERERERKcaJBSIiIiIiIiIiIiIiUowTC0REREREREREREREpJidpQNIRwhLJyAiIiIiIiIiIiIikhaPWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIpxYoGIiIiIiIiIiIiIiBTjxAIRERERERERERERESnGiQUiIiIiIiIiIiIiIlKMEwtERERERERERERERKQYJxaIiIiIiIiIiIiIiEgxTiwQEREREREREREREZFinFggIiIiIiIiIiIiIiLFOLFARERERERERERERESKcWKBiIiIiIiIiIiIiIgU48QCEREREREREREREREp9p+bWOjWrRvy5cunt0yj0WDChAkWyaMUc5uftWa31tyA9WZnbvOz1uzWkNsaMibHWrMzt/lZa3ZrzQ1Yb3ZrzQ1Yb3bmNj9rzW6tuQHrzc7c5met2a01N2C92Znb/Kw5u6n8KyYWNBqNon+HDh0yW6bg4GBUr14dLi4uyJEjBwYOHIi3b99KnfvPP/9EYGAgSpYsCVtbW4NfDhlzR0VFYeHChWjQoAF8fHzg5uaGsmXL4qeffkJ8fLzU2QFg2rRp8Pf3h5eXF5ycnFCoUCEMHjwYYWFhUudO7PXr18iePTs0Gg02b95scLts2WvXrm308Rs1aiR1bgCIiYnBtGnTULRoUTg5OcHb2xtNmzbFo0ePpMx97969FDP07NlTb32ZsgNAQkICfv75Z5QpUwaZMmWCt7c3GjdujODgYKlzx8bGYuLEifDz84OjoyP8/Pyky6i0bwD5xtcau/K/kPvJkydWm91ac6e2j5c5u7XmnjBhgtVmZ+70s+bXPWqyW2vuGzduWG125jZvbtn6878w5rL1539hzGXKDSh/783as0+dOhUtWrSAt7c3NBrzTHDYZfgjmMHq1av1vl61ahX27dtnsLxYsWJYunQpEhISMjTPhQsXUK9ePRQrVgxz5szBo0eP8P333+PWrVv4448/pM29bt06bNiwAeXKlYOvr2+y68mU+86dOxgwYADq1auHb775BpkzZ8bevXvRt29fnDhxAitXrpQ2OwCcPXsWZcqUQYcOHeDm5obr169j6dKl+P3333HhwgW4urpKmTuxcePGISoqKtnbZcyeK1cufPfdd3rLkj7nZcsdGxuLpk2bIjg4GD179kTp0qXx6tUrnDx5EhEREciVK5d0ub28vAweFwD27NmDtWvXokGDBnrLZcoOAMOGDcOcOXPQuXNn9O3bF69fv8bixYtRq1YtBAUFoVKlSlLm7ty5MzZt2oQePXqgQoUKOHHiBO7evYvatWsjMDBQioxK+wYAmjVrht27d6N27drw8/PDzp078eLFC/Tt2xdVqlSRNvvq1avRpUsXuLu7I0+ePLh8+bJueWKy5W7cuDEOHz6MihUrws/PD8eOHcOtW7eg0WgwfPhwlCxZUsrcL168QNGiRVG4cGF4enoiPj4ef/zxB8LCwtC8eXO0a9dOt65s2RM/J96/f4/+/fvjw4cPcHR0xLJly6TNreXv748yZcoAAI4dO4YrV67ghx9+QLZs2XTryJZ99erVuH//PqZOnQoPDw+4urri1q1baNmyJcLDw9GrVy8pc7dp0wahoaF6y7Rj7uLigoULF8LOzk7K7EuXLsXIkSPx4cMHBAQEICQkBNeuXYOtrS1y5syJyZMnw8bGRrrcc+fOxbfffgsbGxs0bNgQly5dws2bN2FjY4NRo0ahaNGiAOR83SNTf6rJLlN/qsm9bNkyuLi46PozOjoaO3bsQHR0NEaMGKHrTxmzT506FatXr9Z16PHjx3Hjxg0A0OtQ2XLL1J9qfz8BefpT7ZjL0p9qcsvWn2qyy9SfanLL1J+A8vfeALn6U232b7/9Fjly5EDZsmWxd+/eDM2lI/6F+vXrJ9R8awDE+PHjTfb4jRs3Fj4+PiIiIkK3bOnSpQKA2Lt3b7L3s3Tux48fi5iYGCGEEE2bNhV58+ZVdD9L5g4LCxNXrlwxWN69e3cBQNy6dSvF+1t6zI3ZvHmzACDWr1+f7Dqy5L58+bKws7MTkyZNEgDEpk2bUr2PpbPXqlVLlChRQvX9LJ17xowZwt7eXpw8eVLV/Syd25h69eqJzJkzi+jo6BTXs2T22NhY4ezsLNq2bau3/M6dOwKAGDhwYLL3tWTuU6dOCQBi7NixesuHDBkiNBqNuHjxosUzCqG8bx49eiTs7e1Fv379dMv69u0rAIhcuXKJuLi4VB/Lkl159+5dIcTHrgJgFWN+5swZ8ebNG93X2ueKl5eXqFatWqqPI8vfJkL8k93V1VX654rWiBEjRJYsWXS5lbBU7rt37woAYtasWbpl1rJviY+PFyVLlhSVK1cWUVFRVpPbmK5duwoAomfPnorWt1T2tWvXCgBi9+7dQoh/nivjxo0TAMS5c+ekzN23b19hZ2cnbty4oZc7d+7coly5cqk+jqVe98jWn2pfs8nSn2pyJ+1PIYQIDAwUABT1pxDyvE7WPs+bNWumqENlyG3p/lSTW7b+VJNdpv5M73tBluxPNdll6k81uWXqz+QYe+9Ntv5MTnLvGybtz4zOIYQQ/4pTIalh7PxXxjx+/Bg9evSAt7c3HB0dUaJECfzyyy+p3i8yMhL79u1D586dkTlzZt3yL774ApkyZcLGjRulzA18/MS2vb19mvIlJ6NzZ8uWDSVKlDBY3rp1awDA9evXVWfWMseYG6N9zNevX6fp/ubMPWjQILRu3Ro1atRIU9akzJk9Li7O4PRkaZXRuRMSEjBv3jy0bt0alSpVQlxcXIpHiciS25inT5/i4MGDaNOmDZycnNK0DSDjs8fGxiI6Ohre3t56y7Nnzw4bGxs4OztLmfvo0aMAgA4dOugt79ChA4QQ2LBhg8UzAsr7ZseOHYiNjUXfvn11yzQaDQDg0aNHOH78uLTZASjKAsiVu3z58siUKZPB8ho1ahh0qky5UxIVFYWYmBi9ZTJmv3XrFn744QdUr1492XVkzA0A7969MxjjpGTK/ueff+LKlSsYP348nJ2dERcXZxW5jQkJCQEAdOrUyeA2mbJHRkYCgEGv+vj4AIBer8qU++jRoyhbtiyKFCmit7xFixY4d+4cbt26Zbbcal73yNafal+zydKfanIb60/t37rGXpPKlD05+fLlM+hQGXPL0J9pHW8Z+lNNdpn6M73PcUv2p5rsMvWnmtwy9WdyjL33Jlt/qsmeeLk5/StOhWRqoaGh8Pf3h0ajQf/+/eHl5YU//vgDgYGBiIyMxODBg5O97+XLlxEXF4cKFSroLXdwcECZMmVw/vx5KXNbUkbkfvbsGQDoHUaYEUyRXQiBly9fIi4uDrdu3cLIkSNha2uL2rVrS51706ZNCA4OxvXr13Hv3r0My5qUKbKHhITA1dUVMTEx8Pb2Rs+ePTFu3DiTT6yZKve1a9fw5MkTlC5dGr169cLKlSsRExODUqVKYd68eahTp46UuY357bffkJCQYPQPOFNLT3ZnZ2dUrlwZv/76K6pUqYIaNWrg9evXmDx5Mjw8PHSH+cqW+8OHD7r8ibm4uAD4eBilpTOqcf78ebi6uqJYsWLJ3p7Si0hj2JVp8+zZszR1qrlzR0dH4927d3j79q3uNA5VqlRJ02SgubMPHjwYderUQd68edO1HXPnnjhxIoYNGwaNRpPuv7vMlX3//v0AAEdHR1SoUEG3b+zQoQMWLVqErFmzSpnbGO0bIzVr1kzT/c2VvWbNmrCxscGgQYMwe/Zs3Yc7pk6dilatWulOiSBb7g8fPsDDw8NgeeJeLVSokEVzG3vdYy39aY7XbDLkTuv3Z+7s2g7VvpG5YsWKNHWouXPL3J8p5Za9P41lt4b+VPr7KWN/GstuDf1pLLeM/ankvTdZ+9MS7xsqluHHRFhASodjde3a1eBQVyQ5PCQwMFD4+PiIFy9e6K3XoUMH4e7uLqKiopJ97E2bNgkA4siRIwa3ffbZZyJHjhxS5k7KVKdCMnduIYT48OGDKF68uMifP7+IjY2VPvvTp091h/ji/w+v2rBhg9S5o6KiRJ48ecSoUaOEEEIcPHjQJKdCMkf2Hj16iAkTJogtW7aIVatWiRYtWggAol27dtLm3rp1qwAgPD09RaFChcSKFSvEihUrRKFChYSDg4Pu9Day5TamfPnywsfHR8THx6e6rqWz37p1S5QrV07v99PPz093OKeMubds2SIAiNWrV+st//nnnwUAUbJkSYtnTCqlvmnatKnw8/PTW6bNDkCMHDlS2uyJpXYqB1lzC/HPeGs0GoNTbMmY+7vvvtP7nQUgHjx4YLCebNl3794t7OzsxNWrV/VO4SRz7vv374sGDRqIn376SezcuVPMnTtXZMqUSe9wfVmza7vf09NTdOrUSTRq1EgAEHZ2dqJq1aoiISFBytxJXblyxar2LcuWLdOdqkT7r2vXrgZ/r8uUu3nz5iJLliwiMjJSCPHPPrFKlSoCgPj+++8tlluI5F/3yN6fKWVPTLb+VJpbq3Xr1gIwPEWlrNmTdmi9evUMOlS23LL2Z0q5Ze/PlLLL3J8p5U5Ktv5MLbus/ZlSbhn7U8l7b7L2p9r3DXkqJAsSQmDLli1o3rw5hBB48eKF7l/Dhg0RERGBc+fOJXv/6OhoAB9ncJNycnLS3S5bbkvJiNz9+/fHtWvXsGDBAt0FeDKCqbJnzZoV+/btw65duzBp0iRky5bNZKfoyajc06dPR2xsLEaPHp1hOY0xRfbly5dj/PjxaNOmDbp06YIdO3agZ8+e2LhxI06cOCFlbu3z4c2bNzhw4AC6deuGbt26Yf/+/RBCYObMmVLmTiokJARnz55Fhw4dYGOTsfVjiuxubm4oUaIE+vXrh61bt2LRokWIi4tDq1at8OLFCylzN2nSBHnz5sXQoUOxdetW3L9/Hxs3bsSYMWNgZ2dnkg4yZ99ER0cb7dPEt6vBrlRPO8b58+fH8OHDVd3XErk7duyIffv2Yd26dbpPQaXleW/O7DExMfj666/Rp08fFC9ePF3bMmfuPHnyYO/evejTpw+aN2+OQYMGoX379gCAIUOGSJ1d26sVK1bEmjVrUKBAAQDA5MmTERwcjAMHDkiZO6m1a9em6/7mzp4zZ05UqlQJc+fORePGjQF8/B5Gjhwpbe6vvvoKr1+/Rvv27XH+/HndKQfOnDkDQN3+xZyve6yhP83xms2SuZ8/f44///wTAFT3p6Wyazu0fv36umUyP1dk78/kcltDfyaXXfb+VPr7KWN/ppRd5v5MLreM/ankvTdZ+9Pc7xuqwVMhJREWFobXr19jyZIlWLJkidF1nj9/nuz9tYcJak9Hkdj79+/TfF7u1KQ3t6WYOvesWbOwdOlSTJ48GU2aNDFVTKNMld3BwQEBAQEAPl59vl69eqhWrRqyZ8+OZs2amTQzkP7c9+7dw6xZs7Bw4UKj5+HOSBn1PB8yZAiWLl2K/fv3w9/fP70xDZhqv1KtWjXkzp1btzxPnjyoXr06goODTRv4/5l6vLV/wJnjNEjpzR4XF4eAgADUrl0b8+fP1y0PCAhAiRIlMGvWLMyYMUO63E5OTvj999/Rrl07fPrppwA+TnTPnDkTU6dONcnvrDn7xtnZ2WifJr5dDXalOu/evcPu3bsBfDzfqNrnjyVy582bV3cqhKCgINy6dQsBAQG4efOmqueLObP/8MMPePHiBSZOnJjubVn6Oa49n/jNmzfx6NEj5MqVS/F9zb1vAT6+iZbY559/jlGjRiE4OFj3t1lqLDXmQgisW7cOWbNmRXh4eJq2Yc7sQUFBaNasGU6cOIEKFSrozq387bffYuLEiejRo4fiNwbNmbtx48aYP38+Ro4ciXLlyumWT506FcOHD1e1XzTn6x7Z+9Ncr9kslfvdu3do1qwZYmNjASBNf39ZIru2Q7dv3459+/bBz89PdYeaM7fM/an2OS5Tf6a2bwHk7E+lYy5jf6aUXeb+TCm3jP2p5L03WfvT3O8bqsGJhSQSEhIAAJ07d0bXrl2NrlO6dOlk76+9gMrTp08Nbnv69Cl8fX1NkNJQenNbiilz//rrrxgxYgT69OmDb7/91mQZk5NRY161alX4+Phg7dq1GbKDSG/ucePGIWfOnKhdu7bu2grac+qFhYXh3r17yJMnT4Z8Ij2jxlz7Zn1a/7BITXpza/cbSS/YBHy8mHBGXbvF1OO9bt06FClSBOXLlzdJvpSkN/uRI0dw5coVzJkzR295oUKFUKxYMQQFBZkubCKmGPMSJUrgypUruHbtGl69eoXixYvD2dkZX3/9NWrVqiVFRqV8fHxw8OBBCCF0F81KTG2nsiuVi4mJQZs2bXRH55QsWVL1NmQZ74cPH+LIkSNo2LCh4vuYK3tERASmTJmCvn37IjIyUvcP+PjC9969e3BxcUH27Nmlyq1EeHi4qjdGzJk9uV7VjvOrV68Ub8tSYx4UFIT79+/D398/zUdcmjP74sWL4e3tbXAduhYtWmDChAkIDg5W/MaIuce8f//+6N69Oy5duoQffvgBmzZtgru7OwCgcOHCirdjztc9MvenOV+zWSK3tj8vXbqEJk2aYPv27apzA3KMedu2bbF06VJVHWqu3DL3Z3qf45bsz9Syy9qfasZctv5MLbus/alkzGXsz8SMvfcmc38mltHvG6rBiYUkvLy84Obmhvj4eMUzrYmVLFkSdnZ2OHPmDNq1a6dbHhMTgwsXLugtM6X05rYUU+XesWMHvvzyS7Rp0wYLFy40YcLkZeSYv3//HhERESbdplZ6cz948AC3b9+Gn5+fwW19+/YF8PEPiixZsqQ3qoGMGvM7d+7otp8R0pu7VKlSsLe3x+PHjw1ue/LkibS5Ezt58iRu376NSZMmmShdytKbPTQ0FAAQHx9vcFtsbCzi4uLSndEYU425RqNBiRIldF//73//Q0JCgkl+b8zZN2XKlMGyZctw/fp1o38wlylTRtX2/utdqVRCQgK++OILHDhwAA0aNMCePXvStB2Zxlttp5or+6tXr/D27VvMnDnT4LR2UVFRyJ8/P1q2bKn4jSmZxlxtN5kze/ny5bF06VKDXn3y5Ikui1KWGvO1a9dCo9GgcOHCaX5jxJzZQ0NDk+1UAKp61RJj7urqiipVquiOvty/fz+cnZ1RrVo1xdsw5+seWfvT3K/ZzJ07cX9u3LgRf/31V5ofU4Yx157yQ02Hmiu3rP1piue4pfpTSXYZ+1PtmMvUn0qyy9ifasZcpv40Jul7b7L2pzEZ+b6hGrzGQhK2trb49NNPsWXLFly5csXg9rCwsBTv7+7ujoCAAKxZswZv3rzRLV+9ejXevn2Lzz77zOSZgfTnthRT5D5y5Ag6dOiAmjVrYu3atRl+7nat9GZ/9+4doqKiDJZv2bIFr169MpiRNpX05p4yZQq2bdum92/y5MkAPp4/dNu2bXB1dZUye2RkpMFhbUIITJkyBQBUfZpVjfTmdnNzQ5MmTRAcHIwbN27oll+/fh3BwcF650E1JVPuV9atWwfg42Gy5pDe7NpPUPz22296y8+dO4ebN2+ibNmypgubSEbsy6OjozF27Fj4+PgYHLYsS8bktGzZEvb29li0aJFumRACwMdzjVatWlXV9v7LXanGgAEDsGHDBixatEh37ty0MGfulLal0Wj0DsFWwlzZs2fPbtCp2nPnOjk5Ydu2bRg1apR0uZPblvZcr6VLl9YdxauUufctjo6OWLFihe6TZACwbNkyAFDVq5bYr8TGxmLTpk2oXr063Nzc0rwdc2YvXLgwQkNDcejQIb3l69evBwBVvSrDvnzr1q0IDAzUffJSCXO+7pGxPy3xms3cuRP3Z5s2bawme3LbWr58ueoONVduGfszPeNt6f5Us2+RqT/V7ldk6k+l2WXrz/Tuyy3Rn2ree5OtPy31vqEaPGLBiOnTp+PgwYOoXLkyevbsieLFiyM8PBznzp3D/v37Uz1dytSpU1G1alXUqlULvXr1wqNHjzB79mw0aNAAjRo1kjb3pUuXsHPnTgDA7du3dYcXAsAnn3yC5s2bS5f7/v37aNGiBTQaDdq2bYtNmzbp3V66dOkMPeQ/Pdm1531u3749ihYtChsbG5w5cwZr1qxBvnz5MGjQIClzV69e3WCZ9uiEihUrolWrVhmU+qP0ZD937hw6duyIjh07omDBgoiOjsa2bdsQFBSEXr16qX7jyVy5AWDatGk4cOAA6tati4EDBwIAfvzxR2TNmjVDL6Kd3tzAx0/9b9iwAf7+/ul6k1Kt9GQvX7486tevj5UrVyIyMhINGjTA06dPMX/+fDg7O2Pw4MFS5gaAdu3awdfXF8WLF0dkZCR++eUX3LlzB7///nu6/oA2ZUalfZMrVy4MHjwYs2bNQmxsLCpWrIjff/8dADBz5kzY2tpKmx34+KGC+/fv6/0xqF23S5cuumsByJR77ty5WLRoEapUqQIXFxfcvHkTALBmzRoAQOvWrVVNHpsr99SpUxEUFIRGjRohT548CA8P1/1N0L9/fxQsWFBxZnNmd3FxMejN/fv3A/j4QiQtnWquMR8+fDj+/vtv1KtXD76+vrh3755uMnbevHmqc5sze44cOTBmzBiMGzcOjRo10n3oYPr06ejYsSMqVqwoZW6tvXv34uXLl+jUqRMuX76sKqulsvfv3x8rVqxA8+bNMWDAAN2L67lz56J+/fqoXLmylLnv37+Pdu3aoUWLFsiRIweOHTsG4ONrjGnTpqnKnN7cal73yNafal+zydKfanIn7c81a9bodaja/jRn9qQdqr2Q6K5duzBgwADVHWqO3LL1p5rxlq0/1WSXqT/T8l6QLP2pJrtM/akmt0z9qea9N9n6U+37hkn788iRI2nuT8XEv1C/fv1Ect9a165dRd68efWWARDjx4/XWxYaGir69esncufOLezt7UWOHDlEvXr1xJIlSxRlOHr0qKhatapwcnISXl5eol+/fiIyMlLq3CtWrBAAjP7r2rWrlLkPHjyYbGZjjyNT9rCwMNGrVy9RtGhR4erqKhwcHEShQoXE4MGDRVhYmLS5jdH+HDZt2pTqupbMfufOHfHZZ5+JfPnyCScnJ+Hi4iLKly8vfv75Z5GQkCBtbq2zZ8+KgIAA4erqKtzc3ETLli1FSEiI9Ln37NkjAIgff/xR0fqyZI+KihKTJk0SxYsXF87OzsLd3V00a9ZMnD9/XurcM2bMEEWLFhVOTk7Cw8NDtGjRwiCzpTOq6Zv4+Hgxbdo0kTdvXuHg4CCyZs1qNdlr1aqV7LoHDx6UMnfXrl1T7NW7d+9KmfvPP/8UzZo1E76+vsLe3l64ubmJHDlyCABG9+8yZU9K+/vp6uoqde5169aJmjVrCi8vL2FnZyeyZcsm/Pz8rOb3MyEhQcyfP18ULlxY2NjYCADi22+/FTExMVLnFkKIDh06CHt7e/Hy5Uur2p/fuHFDtG3bVuTOnVs35kOHDhXv3r2TNnd4eLho2bKlyJEjh3BwcBBubm4CgNHXdbK97pGpP9Vml6U/1eRW05+yZU/aofb29gKAWLFihUGHypQ7KUv2p5rcsvWn2jGXpT/T8lyRpT/VZpelP9Xklqk/1b73JlN/qs2utD9NSSPE/x/TQURERERERERERERElApeY4GIiIiIiIiIiIiIiBTjxAIRERERERERERERESnGiQUiIiIiIiIiIiIiIlKMEwtERERERERERERERKQYJxaIiIiIiIiIiIiIiEgxTiwQEREREREREREREZFinFggIiIiIiIiIiIiIiLF7CwdQDYajSbZ24QQZkyijrXmBqw3u7XmBqw3O3Obn7Vmt9bcgPVmZ27zs9bs1pobsN7szG1+1prdWnMD1puduc3PWrNba27AerNba27AerMzt/lZa3ZrzQ1Yd/akeMQCEREREREREREREREpxokFIiIiIiIiIiIiIiJSjBMLRERERERERERERESkGCcWiIiIiIiIiIiIiIhIMU4sEBERERERERERERGRYhphbZebJiIiIiIiIiIiIiIii+ERC0REREREREREREREpBgnFoiIiIiIiIiIiIiISDFOLBARERERERERERERkWKcWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIpxYoGIiIiIiIiIiIiIiBTjxAIRERERERERERERESnGiQUiIiIiIiIiIiIiIlKMEwtERERERERERERERKQYJxaIiIiIiIiIiIiIiEgxTiwQEREREREREREREZFinFggIiIiIiIiIiIiIiLFOLFARERERERERERERESK/WsnFrp164Z8+fLpLdNoNJgwYYJF8qhhrdmZ2/ysNbu15gasN7u15gasNztzm5+1ZrfW3ID1Zmdu87PW7NaaG7De7Mxtftaa3VpzA9abnbnNz1qzW2tuwHqzM7f5WXN2U7GqiQWNRqPo36FDh8ySZ9q0afD394eXlxecnJxQqFAhDB48GGFhYXrr3bhxw2qzM7d5c9+7d89qs1tr7gkTJlhtdmvNLWP2xF6/fo3s2bNDo9Fg8+bNzG3B3KdPn7ba7Naa25qzM7d5c3fr1s1qs1trbhmz165d2+jjN2rUiLktmFvG/vy3j7k1Z2du8+aWsT//7WMuY3YAiImJwbRp01C0aFE4OTnB29sbTZs2xaNHj5jbQrll7E+l2a9evYrPPvsMfn5+cHFxQbZs2VCzZk3s2rUrQ7PZZejWTWz16tV6X69atQr79u0zWF6sWDEsXboUCQkJGZrn7NmzKFOmDDp06AA3Nzdcv34dS5cuxe+//44LFy7A1dUVALBs2TK4uLigYsWK8PPzQ3R0NHbs2IHo6GiMGDECJUuWlDb71KlTsXr1ahQuXBienp44fvw4bty4AQBo3rw52rVrJ2XuxM+J9+/fo3///vjw4QMcHR2xbNky3W2y5dby9/dHmTJlAADHjh3DlStX8MMPPyBbtmzSZl+9ejXu37+PqVOnwsPDA66urrh16xZatmyJ8PBw9OrVS8rcbdq0QWhoqN59tWPu4uKChQsXws7OTsrsS5cuxciRI/HhwwcEBAQgJCQE165dg62tLXLmzInJkyfDxsZGutwPHz5EpkyZYGNjg4YNG8LR0RHbt2/H27dvMWbMGBQtWlS3TXNlT2zcuHGIiooyetvq1auxcOFCnDp1Co0aNcLdu3dx/fp12NjYYPTo0ShSpIiUuefMmYNvvvkGnp6e8PLy0u3HLdWfiaWUe8aMGXB3d0elSpWQJ08evH79Grt27dL9YZU7d27durJlHzJkCP78808ULFgQHh4eCAoKws2bNwEA3bt3R926daXMDfzzvAgPD8ewYcMQFxeHhIQE6Z8vo0ePxrRp09CgQQP4+fnp9uV9+vRB6dKl4ebmJmXu1atX4/Lly5g9ezby5csHW1tbhISEoFmzZkhISEDHjh2lzN27d284OzvrLdOOua+vL2bMmKFbLlv2uXPnYvTo0XB2dka9evVw+fJlXL9+HQBQtmxZfPPNN1LmPnfuHOzt7ZE1a1bUrVsXQghs374d79+/x8yZM+Hj46Nb15zZc+XKhe+++05vma+vr97XMvanktwy9qeS3LL2p5LsMvanktyAnP2pJLuM/al0vyJbfyrJLWt/KskuY38qyS1jf8bGxqJp06YIDg5Gz549Ubp0abx69QonT55EREQEcuXKBUC+/lSaW7b+VJpbxv5Umv3+/ft48+YNunbtCl9fX0RFRWHLli1o0aIFFi9erHtPzuSEFevXr59Q8y0AEOPHj8+4QEKIzZs3CwBi/fr1umVnzpwRb9680VsvMDBQABDVqlVTtF1LZU9KO+bNmjUTrq6uIi4uLsVtypB7xIgRIkuWLAKAcHV1VbRNS+W+e/euACBmzZqlW2Ytz/P4+HhRsmRJUblyZREVFWU1uY3p2rWrACB69uypaLuWyr527VoBQOzevVsI8c9zZdy4cQKAOHfuXIrbtFTuvn37Cjs7O3Hjxg3dst69ewsAoly5coq2m1HZL1++LOzs7MSkSZMEALFp0ya920+ePKn3O6od8wIFCogqVapIm/v9+/fi6dOnQgghTp8+LQBI8fuZWu6goCDx4cMHvWWdOnUSAESnTp0UPYalsielfa588sknokiRIqluX4bc7du3F3Xr1hW+vr5W8Xw5ePCg3nJZeii13BEREcLb21u0bt1axMfHW01uY9q0aSMAiKlTpyp6DEtlnzp1qgAgrly5IoT457nyxRdfCAAiPDxcytxNmjQRHh4e4sWLF7pl3bp1EwBEmzZtFD2GqbPXqlVLlChRItX1ZOtPpbll60+luWXsT6XZk7J0f6Yltyz9qTS7bP2pNLds/ZnW57gQlu9Ppdll60+luWXszxkzZgh7e3tx8uTJFNeTrT+V5patP5XmlrE/lWY3Ji4uTnF/ppVVnQpJDWPnuTLm8ePH6NGjB7y9veHo6IgSJUrgl19+SfPjah/z9evXumXly5dHpkyZ9NZzcnICAN3srqzZU1o3KioKMTExumUy5r516xZ++OEHVK9ePdn7y5gbAN69e6c3vsbIlP3PP//ElStXMH78eDg7OyMuLs4qchsTEhICAOjUqZPBbTJlj4yMBAB4e3vrrav9xEXiT8LIlPvo0aMoW7as7tMVAHRHhZw7dw63bt3S24Y5sw8aNAitW7dGjRo1jN6+efNm2NraGsz2BwYG4vjx43j48KGUuR0dHZEjRw5F25Ipd9WqVeHg4KC3LEuWLAAs35+pZU9O7ty5DfZBMuY+cuQINm/ejLlz56a4nozZAeDNmzcpfnpIptzr1q1DaGgopk6dChsbG8TGxlpFbmO0/fn5558b3CZT9pT608bGRm+/I1Puo0ePIiAgAJ6enrpl2qMBd+/ejbdv3+qtb87scXFxBo+fmKz9mVpuWfsztdwy92dq2ZNj6f5UmlvG/lQz5jL1Z2q5Ze3PtDzHZenP1LLL2p+p5ZatPxMSEjBv3jy0bt0alSpVQlxcXLJHK8rUn2pyy9SfanLL1p9qshtja2trtD9NyapOhWRqoaGh8Pf3h0ajQf/+/eHl5YU//vgDgYGBiIyMxODBg1PdhhACL1++RFxcHG7duoWRI0fC1tYWtWvXVpQh8altZM4eHR2Nd+/e6YpkxYoVqFKlisEhfLLlHjx4MOrUqYO8efOqymnp3BMnTsSwYcOg0WjS/Bwxd/b9+/cD+FggFSpUwNmzZwEAHTp0wKJFi5A1a1Ypcxuj/cOuZs2aqjKbO3vNmjVhY2ODQYMGYfbs2bo/iKZOnYpWrVrpnVJIptwfPnyAh4dHsts4e/YsChUqZPbsmzZtQnBwMK5fv4579+4ZXef8+fMoXLgwMmfOrLe8UqVKAIALFy7oHR4pS25Ts2RuIQQAy/anmuzv3r1DdHQ0IiIiAAB//PEH2rdvL3Xu+Ph4DBgwAF9++SVKlSqlOqslswMfT5Xx9u1baDQaAMCZM2dQoUIFaXPv378fmTNnxuPHj9GqVStdB3311Vf44YcfdB9GkS13UrGxsbqJYSUvsCyZvXbt2pgxYwYCAwMxceJEXX/+9NNPGDhwoMEpKmXJ/eHDh2T/9o6JicGVK1fg7+9v9uwhISFwdXVFTEwMvL290bNnT4wbNw729va6dWTsTyW5Tc2SuWXoTzXZZepPpbll7E81Yy5TfyrJLWN/puX3U5b+VJJdxv5Uklu2/rx27RqePHmC0qVLo1evXli5ciViYmJQqlQpzJs3D3Xq1NGtK1N/qsltapbMbcn+TEv2xP25c+fONPenYhl2LIQZpHSoW9euXUXevHn1liHJ4SiBgYHCx8dH73AoIYTo0KGDcHd3F1FRUalmePr0qe6QHgAiV65cYsOGDaner3Xr1gKAGDt2rFVk/+677/TWrVevnnjw4IHUuXfv3i3s7OzE1atXdc8VY6dCkin3/fv3RYMGDcRPP/0kdu7cKebOnSsyZcqkd7obWbO3aNFCABCenp6iU6dOolGjRgKAsLOzE1WrVhUJCQlS5k7qypUrKR6mJ1v2ZcuW6U71pf3XtWtXERsbK23u5s2biyxZsojIyEjdMu3vKADx/fffmz17VFSUyJMnjxg1apQQwvCQcK0SJUqIunXrGuS+evWqACB+/vlnKXMnltqhqLLm1goICBAAxPLly60iu/Y0X9p/bdu2NThMXLbcCxYsEO7u7uL58+dCCJHiqRxkyh4UFCQ+/fRTsXz5crFjxw7h7+8vAAgnJyeDU8PJlLt06dLCxcVFuLi4iAEDBuj6E4Do0KGDtLmT2rVrl1XtWyZPniycnZ31fj/HjBkjde5SpUqJwoUL652KtE+fPrr8mzdvNnv2Hj16iAkTJogtW7aIVatW6f4ebNeund56svWn0tyJydCfacmtZen+VJtdlv5Uk1u2/lSaXbb+VJpbtv5M6++nDP2pJrtM/ak0t2z9uXXrVt17J4UKFRIrVqwQK1asEIUKFRIODg7i4sWLunVl6k81uROzdH+mNbeWJfszLdkT96eNjY3R/jSlf+2pkFIjhMCWLVvQvHlzCCHw4sUL3b+GDRsiIiIC586dS3U7WbNmxb59+7Br1y5MmjQJ2bJlS/Wwt+fPn+PPP/8EAAwfPtwqsnfs2BH79u1D/fr1dcuio6OlzR0TE4Ovv/4affr0QfHixVXltGTuPHnyYO/evejTpw+aN2+OQYMG6WYWhwwZInV27dcVK1bEmjVrUKBAAQDA5MmTERwcjAMHDkiZO6m1a9cqzilD9pw5c6JSpUqYO3cuGjdurPseRo4cKW3ur776Cq9fv0b79u1x/vx5hISE4OjRo7rbLbFvmT59OmJjYzF69OgU14uOjoajo6PBcu0notRkN2duU7Jk7hs3buDw4cMAgK5du1pF9sGDB2Pfvn2oV68egI+fZkztNHeWzP3y5UuMGzcOY8eOhZeXl6qcls5etWpVbN68GT169ECLFi1Qvnx5AIBGo8GoUaOkzf327VtERUXhiy++wI8//qjrz969e+O3334zOD2cLLmTWrduHWxs0v7SwtzZ8+XLh5o1a2LJkiVo1KgRAGDatGlYsGCBtLn79u2LkJAQBAYG4tq1a7hy5YruiFHAMv25fPlyjB8/Hm3atEGXLl2wY8cO9OzZExs3bsSJEyf0ssnUn0pzm5Ilc8vQn2qzy9KfSnPL2J9Ks8vWn0pzy9afaf39lKE/1WSXqT+V5patP7Wvj9+8eYMDBw6gW7du6NatG/bv3w8hBGbOnKmXTZb+VJPblCyZ29L9mZbs2v5cuXIlGjdunKb+VCV98xKWlZ4jFkJDQ/VmWI3927p1q+pMQUFBAoDYtWuX0dvfvn0rKlasKBwcHKwuuxD/jHnPnj1F7ty59WbWZMo9ffp04eHhIV6+fKmXOy1HLFhyvBNnByAePnwobfamTZsKAGLlypV6ue/fvy8AiIkTJ0qZO7GEhASRN29ekTVrVqv4/Tx27JiwtbUVp0+fFkL8M+YTJkwQGo1GXL16VcrcQggxf/584erqqtu2u7u77v9/+OEHvXUzOvvdu3eFs7Oz+OWXX3TLzHHEgjlzJ5beT4xYKvfTp0+Fn5+f7igua8ouxD/Plfr164uKFSuqOorLnLn79OkjChYsqHfRsvR84lKGMe/QoYNwcHDQ+5SaTLlLlCghAIjDhw/r5T58+LBer8qWO7E3b94IFxcXkTdvXqt4rqxfv144Ozvr/q7Sjnm3bt2Ei4uL3ifKZMothBCjR48W9vb2um17eXnp/n/btm1661qq+2/cuCEAiMmTJ+uWydSfanInZun+TGtuGfozrdmFsGx/qsktW3+qyZ6UJftTTW6Z+lNN7sRk6E812WXqTzW5hZCrPzdt2iQAiDp16hjcVqdOHZE/f37d1zL1p5rciVm6P9OaW4b+TGv2xIz1pyn9Z6+xoL0gUefOnZOddSpdurTq7VatWhU+Pj5Yu3YtmjVrpndbTEwM2rRpg0uXLqFJkybYvn276u0DlsmeVNu2bbF06VIcOXIEDRs2VLR9c+WOiIjAlClT0LdvX0RGRur+AYAQAvfu3YOLiwuyZ88uVW4lwsPDkStXLsWPYc7svr6+AAwv5KQd51evXkmZO7GgoCDcv38f/v7+af60mjmzL168GN7e3gbnPm3RogUmTJiA4OBgxUfsmHvM+/fvj+7du+PSpUtwcHDAL7/8gkWLFgEAChcurOox0pt93LhxyJkzJ2rXrq07r/WzZ88AAGFhYbh37x7y5MkDGxsb+Pj44PHjxwbbePr0KYB/fg9ky21KlsgdERGBxo0b4/Xr12jevDnWr19vNdmTatu2LXr37o2QkBC9C5jLkPvvv//GkiVLMHfuXDx58kR3//j4eADAvXv3kDlzZlXXzJFhzHPnzo2YmBi8e/fO4Py0MuT29fXF1atXpejPtI739u3bERUVhSJFiuD+/fuK81oq+6JFi1C2bFmDv6latGiBX3/9FefPn0dAQIB0uYGP11EaOnQorl69Cnd3dyxevBgLFy4EYP7+TI72XM/h4eG6ZTL1Z3KM5TYlS+SWpT+To2bMLdGfyUma+9atW9L1p9Lsqa1r7v5MKQugn1um/kxOauMtQ38mx1h2mfpTTW5Arv5M7r0T4OPz9/z587qvZepPNblNyRK5ZelPU4x5WvpTjf/sxIKXlxfc3NwQHx+veMen1Pv373UXmdJKSEjAF198gQMHDmDjxo3466+/0rx9c2c3Rnu4lZJ1tcyV+9WrV3j79i1mzpxpcFhQVFQU8ufPj5YtWyqe2JFhvBNnUcOc2cuXL4+lS5calJ72j2s12S015mvXroVGo0HhwoXTPLFgzuyhoaG6FyyJxcbGAgDi4uIUb9sSY+7q6ooqVaoA+HhBeABwdnZGtWrVVG0/vdkfPHiA27dvw8/Pz+C2vn37Avi4X8mSJQvKlCmDgwcPIjIyUu8F1smTJwEAZcqUkTK3KZk79/v379G8eXOEhIRg//796TpdmQxjbon+VJr78ePHSEhIwMCBAzFw4ECDdfPnz49BgwZh7ty50mVPaczv3LkDJycnZMqUScrc5cuXx759+/D48WO9P/Yt0Z9pHe+1a9ciU6ZMyJ8/v+rH1DJn9tDQUHh4eBisZ4n+TMuYe3h4oHr16nrr5sqVC0WLFlX12BnV/Xfu3NFtX0um/kyOsdymZO7cMvVnctSMuUyvP5PmlrE/k6NmzC3Rnyll0W5fS6b+TE5q4y1DfybHWHaZ+jM5KY25LP1ZqlQp2NvbG50wePLkibT9qSa3KZk7t0z9aYoxT0t/qvGfvcaCra0tPv30U2zZsgVXrlwxuD0sLCzF+7979w5RUVEGy7ds2YJXr14ZfIJ4wIAB2LBhAxYtWoQ2bdpYTfbktrV8+XJoNBqUK1dOutzZs2fHtm3b9P5pzz3v5OSEbdu2qTpXpKXHW3tOtdKlS8PHx0dxbnNnb9myJRwdHbFixQrdrCwALFu2DAD0rs8hU26t2NhYbNq0CdWrV4ebm5virJbMXrhwYYSGhuLQoUN662pn08uWLStlbmO0n7gIDAyEu7u74txA+rNPmTLFYJ8xefJkAB+vg7Nt2za4uroC+DjbHx8fjyVLluhtY8WKFahcubLuEzKy5TYlc+aOj49H+/btcfz4cWzatEk3EWUN2Z8/f250G6tWrYKzs7Oq6/+YK3fJkiUN1tu2bZvuE5bbtm1DYGCg4tzmzJ7Stnbu3IkGDRqoOnrHnLnbtWsH4OPfVoktW7YMdnZ2qF27tpS5E29z//79aN26Nezs0v6ZJXNmL1y4sO4aP4mtX78eNjY2qj4hael9ufYc4oMHD1Z9hFp6s0dGRuLDhw96y4QQmDJlCgDoHdUsU3+qyW1K5swtW3+qyS5TfyrNLWN/qhlzmfpTTW6Z+jMt+xVZ+lNNdpn6M737ckv2p5ubG5o0aYLg4GDcuHFDt/z69esIDg7We+9Epv5Uk9uUzJlbtv5Uk91Yf8bGxqapP9X4zx6xAHy8UNrBgwdRuXJl9OzZE8WLF0d4eDjOnTuH/fv3p3h44K1btxAQEID27dujaNGisLGxwZkzZ7BmzRrky5cPgwYN0q07d+5cLFq0CFWqVIGLiwvWrFmDmzdvAgDWrFmD1q1bq37zx1zZp06diqCgIDRq1Ah58uTRXVRk165dGDBgAAoWLChdbhcXF7Rq1UrvvtoL89ja2hrcJktu4OMLyL///hv16tWDr68v7t27h99++w0AMG/ePNW5zZk9R44cGDNmDMaNG4dGjRrpSn769Ono2LEjKlasKGVurb179+Lly5fo1KkTLl++rCqrpbL3798fK1asQPPmzTFgwABdUc2dOxf169dH5cqVpcx9//59tGvXDi1atECOHDlw9epV7NixA8DHC3+lRXqyJ/3UCgDdJ0MrVqyot8+oXLkyPvvsM4waNQrPnz/H1atXAXw8xD3pixqZcgPAggUL8Pr1a71D9LV/eA8YMEDVhI65cg8ZMgQ7d+5E8+bNER4ebtCfnTt3VpzZ3Nl79+6NyMhI1KxZEzlz5sSZM2cAAOfOncPs2bNVffrPXLmzZctmtCP79esHAGnqT3NlB4D27dvD2dkZVatWRfbs2XHs2DEAH/8umD59urS5y5Ytix49euCXX35BXFyc7jQ469evx6hRo1Qd4m7O3FobNmxAXFwcOnXqhF27dqnKaqnsw4YNwx9//IEaNWqgf//+ut7fvn07vvzyS2nH/MiRI5g0aRIaNGgAT09PnDhxAvv27QMAo3/bZHT2c+fOoWPHjujYsSMKFiyI6OhobNu2DUFBQejVq5feB5Bk6k81uQF5+lNNbtn6U012mfpTaW4Z+1PNmMvUn2pyy9SfavcrgDz9qSa7TP2pJrds/Ql8fN174MAB1K1bV3ek048//oisWbNi9OjRuvVk6k81uQF5+lNNbtn6U032pP357NkzrF27Fjdu3EhTfyqWIVduMJP0XLxZKzQ0VPTr10/kzp1b2Nvbixw5coh69eqJJUuWpPjYYWFholevXqJo0aLC1dVVODg4iEKFConBgweLsLAwgyxI4UIdd+/elTb7n3/+KZo1ayZ8fX2Fvb297mI3K1asMLjwh0y5k0rPxZvNmXvdunWiZs2awsvLS9jZ2Yls2bIJPz8/q3ieC/Hx4sfz588XhQsXFjY2NgKA+Pbbb0VMTIzUuYUQokOHDsLe3l68fPnSavYtQny8OFXbtm1F7ty5dWM+dOhQ8e7dO2lzh4eHi5YtW4ocOXIIBwcHkT9/flGuXDmLjbkxKV04Mzo6WgwdOlTkyJFDN+Z79uyRPrf2onCp9ZBMuWvVqpVifyYlU/b169eLgIAA4e3tLezs7ISjo6MAIHbs2CF1bmPSc/FJc2afN2+eqFSpksiaNauws7MTLi4uAoC4deuW1LmFECImJkZMmDBB5M2bV7dfSXohexlzCyGEv7+/yJ49u4iLi7Nof6rNfvLkSdG4cWO9ffnUqVNFbGystLlv374tGjRoILJlyyYcHR1F0aJFhb+/v8XG/M6dO+Kzzz4T+fLlE05OTsLFxUWUL19e/Pzzz0YvEChLf6rNLUt/qsktW3+qyS5Tf6p9riRlyf5Uk12m/lQ75rL0Z1qeK7L0p9rssvSnmtyy9afW2bNnRUBAgHB1dRVubm6iZcuWIiQkxGA9WfpTbW5Z+lNNbtn6U032pP3p4eEhAgICjPanKWmEEMJgtoGIiIiIiIiIiIiIiMiI/+w1FoiIiIiIiIiIiIiISD1OLBARERERERERERERkWKcWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIpxYoGIiIiIiIiIiIiIiBTjxAIRERERERERERERESlmZ+kAstFoNMneJoQwYxJ1rDU3YL3ZrTU3YL3Zmdv8rDW7teYGrDc7c5uftWa31tyA9WZnbvOz1uzWmhuw3uzMbX7Wmt1acwPWm91acwPWm525zc9as1trbsC6syfFIxaIyKpkBpDT0iGIiIiIiIiIiIj+wzixQERWIzOAPQAOA8hl4SxERERERERERET/VZxYICKr4QYgO4ACAA7hn8kFTjIQERERERERERGZDycWiMhqPAZQG8Df+Gdyocr//5eIiIiIiIiIiIjMgxdvJiKr8ggfJxcO4ePkQrAlwxAREREREREREf0HaYS1XW6aiAgAgoOBatX++Zq7MiIiIiIiIiIiIrPgxAIRERERERERERERESnGaywQEREREREREREREZFinFggIiIiIiIiIiIiIiLFOLFARERERERERERERESKcWKBiIiIiIiIiIiIiIgU48QCEREREREREREREREpxokFIiIiIiIiIiIiIiJSjBMLRERERERERERERESkGCcWiIiIiIiIiIiIiIhIMU4sEBERERERERERERGRYpxYICIiIiIiIiIiIiIixTixQEREREREREREREREinFigYiIiIiIiIiIiIiIFPvXTix069YN+fLl01um0WgwYcIEi+RRw1qzW2tuwHqzM7f5WWt2a80NWG925jY/a81urbkB683O3OZnrdmtNTdgvdmZ2/ysNbu15gasNztzm5+1ZrfW3ID1ZrfW3ID1ZrfW3KZkVRMLGo1G0b9Dhw6ZLVNMTAymTZuGokWLwsnJCd7e3mjatCkePXr0r8hurbmtOTtzmze3bNnv3buXYoaePXtafe63b99abXbmNm9ua85urbmtOTtzmze3bNkBICEhAT///DPKlCmDTJkywdvbG40bN0ZwcPC/Irds/akmO3ObN7c1Z7fW3NacnbnNm1vG7LGxsZg4cSL8/Pzg6OgIPz8/TJkyBXFxcf+K3DL25799zK9evWq12a0196FDh5LNeuLEiQzLZ5dhW84Aq1ev1vt61apV2Ldvn8HyYsWKYenSpUhISMjQPLGxsWjatCmCg4PRs2dPlC5dGq9evcLJkycRERGBXLlyGWQPDw/HsGHDEBcXh4SEBOmzjx49GtOmTUODBg3g5+eHY8eO4cqVK+jTpw9Kly4NNzc3KXMDwPDhwzF79mzky5cPlStXxvnz53H9+nU0adIEHTt21K0nW/Zx48bh+fPnuvtpx9zBwQHZsmXDjBkzpMw9d+5cjB49Gs7OzqhXrx4uX76M69evAwDKli2Lb775Rsrc586dg729PbJmzYq6detCCIHt27fj/fv3mDlzJnx8fHTbNEd2Ly8vg/0CAOzZswdr165FgwYNdMtWr16NhQsX4tSpU2jUqBHu3r2L69evw8bGBqNHj0aRIkWkzP3ixQsAgKenJ7y8vHDjxg2UKFECV69etcg+UU32ihUrIiQkBJUqVUKePHlw6NAh/P3333B0dMT48eORO3duKXMPGTIEf/75JwoWLAgPDw8EBQXh5s2bAIDu3bujbt26UuYG5OpPNdll6k+1Yy5Tf6rJLlN/qsktU3+qyS1bfwLAsGHDMGfOHHTu3Bl9+/bF69evsXjxYtSqVQtBQUGoVKkSALn6U01u2fpTTXaZ+lNNbpn6U01uQK7+VJNdpv5UkxuQqz/VZJepP9Xklqk/1eSWsT87d+6MTZs2oUePHqhQoQJOnDiBsWPH4sGDB1iyZIluPdn6U2luGftTaXbZ+lNp7vv376NUqVK6/oyJicHu3bvx+vVrvf6UMXvi50R4eDi+/vprJCQkIGfOnJg+fbq0ubUGDhyIihUr6i0rWLBgxgUUVqxfv35CzbcAQIwfP95kjz9jxgxhb28vTp48qfg+7du3F3Xr1hW+vr5Wkf3gwYMCgNi0aZMQwnrGPCIiQnh7e4vWrVuL+Ph4IYT1ZE9KmxuAmDp1aqrrWyr31KlTBQBx5coVIcQ/ub/44gsBQISHh6d4f0vlbtKkifDw8BAvXrzQLevWrZsAINq0aaPosUyd3Zh69eqJzJkzi+joaN2ykydPCgBi1qxZQoh/xrxAgQKiSpUqqW7TUrnfv38vnj59KoQQ4vTp0wKAqFu3rkV/P40xlj0oKEh8+PBB97V2zB0dHUWnTp1S3aalcielzf3JJ5+IIkWKpLpNGXLL0p/GGMsuW38aYyy3jP1pjJrnuaX60xhjuWXrT2OM5ZatP2NjY4Wzs7No27at3vI7d+4IAGLgwIG6ZTL1p5rcsvWnmuwy9aea3ElZsj/TmluG/lSTXab+VJNbtv40xfPcEv2pJrdM/akmt2z9eerUKQFAjB07Vm/5kCFDhEajERcvXtQtk6k/1eSWrT/VZJepP9XkNqZv374CgKL+FEKO7O3btxc5c+YUAESJEiUUPZalciftT3OxqlMhqWHsPFfGPH78GD169IC3tzccHR1RokQJ/PLLL6neLyEhAfPmzUPr1q1RqVIlxMXFISoqKsX7HDlyBJs3b8bcuXOtLjsAvHnzJsWZOJlyr1u3DqGhoZg6dSpsbGzw7t07CCGsIntyNBoNPv/8c2lzR0ZGAgC8vb31lvv4+MDGxgYODg5S5j569CgCAgLg6empW+bq6goA2L17N96+fau3fkZnN+bp06c4ePAg2rRpAycnJ93yzZs3w9bWFr169dJbPzAwEMePH8fDhw+lzO3o6IgcOXIo3o5M2atWrar3XNYqUaKE7hNSMuZOTu7cufH69Wvpc8vSn2nJDli+P9Xklq0/1WRPjiX6U01umfpTTW7Z+jM2NhbR0dEG45g9e3bY2NjA2dlZt0ym/lSTW7b+VJNdpv5Ukzs5lujPtOSWpT/TOuaW7k81uWXrT1M8zy3Rn2pyy9SfanLL1p9Hjx4FAHTo0EFveYcOHSCEwIYNG3TLZOpPNbll60812WXqTzW5jdFoNABg0J+yZtd2aI0aNZLdroy5gY/9mfRUSRnFqk6FZGqhoaHw9/eHRqNB//794eXlhT/++AOBgYGIjIzE4MGDk73vtWvX8OTJE5QuXRq9evXCypUrERMTg1KlSmHevHmoU6eO3vrx8fEYMGAAvvzyS5QqVcqqsgMfD/XVnpcOAM6cOYMKFSpIm3v//v3InDkzHj9+jFatWiEkJAR2dh+f7u/fv1f0RoSlsiel/WO6atWqinZYlspdu3ZtzJgxA4GBgZg4caLuD6KffvoJAwcO1P2xJFvuDx8+JPuHdUxMDK5cuQJ/f3+zZTfmt99+Q0JCAjp16qS3/Pz58yhcuDAyZ86st1x7mO2FCxd0h0bKlDsjWDp7aGgoSpQoIX3ud+/eITo6GhEREQCAP/74A+3bt5c6t0z9qTY7IEd/qsktW3+qyZ6UJftTTW6Z+lNNbtn609nZGZUrV8avv/6KKlWqoEaNGnj9+jUmT54MDw8PvTdBZOpPNbkzgqWzW6I/05Jbhv5Um1um/kzLmMvQn2pyy9af6fn9tGR/qsktU3+qyS1bf3748EH3PSTm4uICADh79qxumUz9qSZ3RrB0dkv0Z1pyJ+7PCxcuAADq1aunOre5syfuUO2+PK3MPeba/rS1tUWNGjUwa9asNPWnYmY9PsLEUjq0sGvXriJv3rx6y5DkcJTAwEDh4+OjdwiaEEJ06NBBuLu7i6ioqGQfe+vWrQKA8PT0FIUKFRIrVqwQK1asEIUKFRIODg4Gh9EsWLBAuLu7i+fPnwshRIqHosqUPSgoSHz66adi+fLlYseOHcLf318AEE5OTuLcuXPS5i5durRwcXERLi4uYsCAAWLLli2iVKlSAoDo0KGDwbZlyp5U06ZNBQCxaNEi6XNPnjxZODs76w6dBSDGjBkjde5SpUqJwoULi7i4ON2yPn366PJv3rzZrNmNKV++vPDx8dEdVq1VokQJUbduXd3X2n3i1atXBQDx888/S5k7MSWHosqaXQj9Q8WXL18ufe7evXvr/X62bdvW4DBx2XLL1J9qssvUn2pyy9afarInZcn+VJtblv5Uk1vG/rx165YoV66c3jj6+fmJGzdu6K0nW38qzZ2YLP2ZluxCWL4/1eaWpT/V5JatP5Vml60/leaWsT/T+vtp6f5Uk1um/lSaW7b+3LJliwAgVq9erbf8559/FgBEyZIldctk6k81uROToT/Tml0Iy/ZnWnIn7U/A+GnKZMueuEO1Y27sVEgy5U7an999953w9PQ02p+m9K89FVJqhBDYsmULmjdvDiEEXrx4ofvXsGFDRERE4Ny5c8neXzsb/ubNGxw4cADdunVDt27dsH//fgghMHPmTN26L1++xLhx4zB27Fh4eXlZVfaqVati8+bN6NGjB1q0aIHy5csD+HgI06hRo6TN/fbtW0RFReGLL77Ajz/+iDZt2qBmzZoAPn7y7tatW9JmTyokJAQA0K5dO1WZLZE7X758qFmzJpYsWYJGjRoBAKZNm4YFCxZIm7tv374ICQlBYGAgrl27hitXrmD//v2626Ojo82aPamQkBCcPXsWHTp0gI2N/i47Ojoajo6OBvfRfiJKTXZz5jY1S2Z/9eoVAKBKlSro2rWr9LkHDx6Mffv26T4lEh8fj5iYGGlzy9afarLL1J9qcsvWn2qyG1sXsEx/qs0tS3+qyS1jf7q5uaFEiRLo168ftm7dikWLFiEuLg6tWrXSXbhRm02m/lSa29Qsmd3S/ak2tyz9qTS3jP2pNLts/ak0t4z9mdbfT0v3p5rcMvWn0tyy9WeTJk2QN29eDB06FFu3bsX9+/exceNGjBkzBnZ2dnp5ZOpPNblNzZLZLdmfacmt7c+VK1cib968AKC6P82d3ZQdas7cSftz5MiROHHiRJr6U+03abXSc8RCaGiowaxZ0n9bt25N9rE3bdokAIg6deoY3FanTh2RP39+3dd9+vQRBQsW1LvgSno+MWLO7Elpx7xDhw7CwcFBb5ZdptwlSpQQAMThw4cNsgMQK1eu1Lu/TNkTe/PmjbCzs7OK58r69euFs7OzePjwoRDin/Hu1q2bcHFx0ZudlSm3EEKMHj1a2Nvb67bt5eWl+/9t27bprZvR2ZMaN26cACDOnDljcJspPzFiztyJmeITI5bK/vTpU5E5c2YBQDx+/Nhqcgvxz3Olfv36omLFiiIhIUHK3LL1p5rsSVmyP9Xklq0/1WRPzNL9qSa3TP2pJrcQcvVnbGysKFmypOjfv7/e8pCQEGFvby+GDx+uWyZTf6rJnZgM/ZnW7Jbuz7TmFsKy/akmt2z9aYoxt0R/qt2vyNSfaR1zS/enmtwy9afa8ZapP4UQ4sqVK6J48eK69R0dHcW8efNE9uzZxSeffKJbT6b+VJM7MRn6M63ZLd2fac2tpX2+JO1P2bIn7dD0HLFg6TEXQhjtT1P6z15jQXvewM6dOyc7y1e6dOlk7+/r6wvA8EJBwMcL9Jw/fx4AcOvWLSxZsgRz587FkydPdOvEx8cDAO7du4fMmTMja9as0mVPSe7cuRETE4N3794ZnF8vOebM7evri6tXrxpdF/hnllcpS4359u3b03XBFXPmXrRoEcqWLYtcuXLprdeiRQv8+uuvOH/+PAICAqTLDQBTp07F0KFDcfXqVbi7u2Px4sVYuHAhAKBw4cKKMpsqe1Lr1q1DkSJFdJ/WSszHxwePHz82WP706VMA/4yDEubMbWqWyB4REYHGjRvrznmoZqy1ZBjztm3bonfv3ggJCUGRIkUU3cdcuWXsT6XZU2KJ/kwqpdyy9WdSSsfc0v2ZVEq5ZepPNbkBufrzyJEjuHLlCubMmaO3vFChQihWrBiCgoJ0y2TqTzW5Tc0S2WXoT1OMuSX6U2luGfvTFGNuif5Uk1u2/kzrmFu6P9Xklqk/1Y63TP0JfLwQ8JUrV3Dt2jW8evUKxYsXh7OzM77++mvUqlVLt55M/akmt6lZIrsM/ZmW3MacPn1aVX+aM7uxDtVeKD42NlZ1h8ow5mnpTzX+sxMLXl5ecHNzQ3x8vOKySaxUqVKwt7c3ulN98uSJ7nCZx48fIyEhAQMHDsTAgQMN1s2fPz8GDRqEuXPnSpc9JXfu3IGTkxMyZcqk+HHNmbt8+fLYt28fHj9+bHRnpfZwJkuN+dq1a2Fvb4/Y2FjVjwmYN3doaCg8PDwM1tNmV/MHqiXG28PDA9WrV9dblitXLhQtWlTVY6c3e2InT57E7du3MWnSJKO3lylTBgcPHkRkZKReQZw8eVJ3u4y5Tc3c2d+/f4/mzZsjJCQEzZo1w5YtW9L0WDKMufbQSe3FKJUwV24Z+zOxtI65JfozsdRyy9afiakZc0v3Z2Kp5ZapPxNTOt6y9GdoaCiAf948TSw2NlZvHGXqTzW5Tc3c2WXpT1OMuSX6U2luGfvTFGNuif5Uk1u2/kzrmFu6P9Xklqk/0zLesvSnlkaj0bsY8P/+9z8kJCTobVOm/lST29TMnV2W/lSbOyVq+hMwX/aUOjQkJER1h8ow5mnpTzX+s9dYsLW1xaeffootW7bgypUrBreHhYWleH83Nzc0adIEwcHBuHHjhm759evXERwcjPr16wMASpYsiW3bthn8085ubdu2DYGBgVJmT2lbO3fuRIMGDVSdO92cubXng1y+fLnBduzs7FC7dm3Fuc2dPfE29+/fDz8/P1VZLZW7cOHCOH/+vO6cnFrr16+HjY2Nqk9IWmK8E9OeA3Xw4MGqrw+Q3uyJrVu3DgDw+eefG729bdu2iI+Px5IlS/SWr1ixApUrV0bu3LmlzG1q5sweHx+P9u3b4/jx49i0aRNy5MiRttAwb+7nz58bXb5q1So4OzujePHiih/LXLll7E+l2VPaliX6M7HUcsvWn4kp3bfI0J+JpZZbpv5Uk9sYS/an9hOev/32m97yc+fO4ebNmyhbtqxumUz9qSa3qZkzu0z9qSa3TP2pNLeM/almzGXqTzW5ZevPtOxbZOhPNbll6s/07stlef2pFR0djbFjx8LHxwcdO3bULZepP9XkNjVzZpepP9XkNtaf2k/vq+1PwHzZjXVo48aNAQB58uRR3aHmHHNj27p48WKa+lON/+wRCwAwffp0HDx4EJUrV0bPnj1RvHhxhIeH49y5c9i/fz/Cw8NTvP+0adNw4MAB1K1bVzeT9eOPPyJr1qwYPXo0ACBbtmxo1aqVwX379esHAEZvkyU7ALRv3x7Ozs6oWrUqsmfPjmPHjgEAXFxcMH36dGlzly1bFj169MAvv/yCuLg41KpVC3v27AEADBs2LE2HjZkru9aGDRsQFxeHwoUL4+bNm6rzmjv3sGHD8Mcff6BGjRro378/Ll++DODj4bRffvml6jE3V+4jR45g0qRJaNCgATw9PXHixAns27cPADBo0CBVmU2VHfj4B8SGDRvg7++PAgUKGF2ncuXK+OyzzzBq1Cg8f/4cV69eBfDxEHdjL2pkyQ0ACxYswOvXr3WHF967dw8AMGXKFAwYMADu7u5SZh8yZAh27tyJ5s2bIzw8XPe7uWbNGgAfD3GUMXfv3r0RGRmJmjVrImfOnDhz5gyAjy92Zs+erfrTC+bILWt/KskOyNefSnPL2J9Ks2vJ0p9Kc8vWn0pzy9af5cuXR/369bFy5UpERkaiQYMGePr0KebPnw9nZ2cMHjxYt65M/akmNyBXf6rJLlN/qsktU38qzS1jf6oZc5n6U01u2fpT7b4FkKM/1eSWqT/V5JatP4GPE2O+vr4oXrw4IiMj8csvv+DOnTv4/fff4ebmpltPpv5UkxuQqz/VZJepP9XkTtqfz549w/r16wF8HPO0fHreHNmNdaj24upubm5p6lBzjXnS/rx27RqWLFmS5v5ULEOu3GAm6bl4s1ZoaKjo16+fyJ07t7C3txc5cuQQ9erVE0uWLFGU4ezZsyIgIEC4uroKNzc30bJlSxESEpLq/dJz8SxzZp83b56oVKmSyJo1q7CzsxMuLi4CgLh165bUuYUQIiYmRkyYMEHkzZtX2NvbC3d3d6sYcy1/f3+RPXt20bdvX6vJffLkSdG4cWORI0cOYWNjIwCIqVOnitjYWGlz3759WzRo0EBky5ZNODo6iqJFiwp/f3+Lj/mePXsEAPHjjz+muF50dLQYOnSo3pjv2bNH+tx58+ZN9uJFd+/elTZ7rVq1Urzwkqy5169fLwICAoS3t7ews7MTjo6OAoDYsWOHwboy5TZGhv5Ukl3G/lQ65jL2p5rni0z9qTS3bP2pJLeM/RkVFSUmTZokihcvLpydnYW7u7to1qyZOH/+vMG6MvWnmtyy9afS7LL1p9LcsvWnmudKUpbuT6XZZetPNWMuW3+qfb7I0p9qcsvUn0pzy9ifM2bMEEWLFhVOTk7Cw8NDtGjRItnniUz9qSa3bP2pNLts/ak0d9L+9PDwELly5bKa53li6bl4szlzJ+1PHx8f0blzZ6P9aUoaIYRIZs6BiIiIiIiIiIiIiIhIz3/2GgtERERERERERERERKQeJxaIiIiIiIiIiIiIiEgxTiwQEREREREREREREZFinFggIiIiIiIiIiIiIiLFOLFARERERERERERERESKcWKBiIiIiIiIiIiIiIgU48QCEREREREREREREREpZmfpALLRaDTJ3iaEMGMSdaw1N2C92a01N2C92Znb/Kw1u7XmBqw3O3Obn7VmN5Y7J4A3ACIkzg38u8Zci7kzhrVmt9bcgPVmZ27zs9bs1pobsN7s1pobsN7szG1+1prdWnMD1p09KU4sEBEREZHZ5ALwKMnXhwA8t0gaIiIiIiIiSgueComIiIiIzOYQPk4mAP9MKhQAkN1CeYiIiIiIiEg9TiwQERERkdkUwMfJhCr4Z1LhbwC1LZaIiIiIiIiI1OKpkIiIiIjIbP7Gx8mE4ERf14b+6ZGIiIiIiIhIbjxigYiIiIjMpmuSi5V1AScViIiIiIiIrI1GWNvlpomIiIjIehUoANy588/Xfn7AoUNA7twWi0RERERERETqcGKBiIiIiIiIiIiIiIgU46mQiIiIiIiIiIiIiIhIMU4sEBERERERERERERGRYpxYICIiIiIiIiIiIiIixTixQEREREREREREREREinFigYiIiIiIiIiIiIiIFOPEAhERERERERERERERKcaJBSIiIiIiIiIiIiIiUowTC0REREREREREREREpBgnFoiIiIiIiIiIiIiISDFOLBARERERERERERERkWKcWCAiIiIiIiIiIiIiIsU4sUBERERERERERERERIr9aycWunXrhnz58ukt02g0mDBhgkXyqGGt2a01N2Ad2a0hozHMbX7Wmt1acwPWm525zc9as1trbsB6szO3+VlrdmvNDVhvduY2P2vNbq25AevNztzmZ63ZrTU3YL3ZrTU3YN3ZM5JVTSxoNBpF/w4dOmSWPLGxsZg4cSL8/Pzg6OgIPz8/TJkyBXFxcf+a7Naa21qyK81YoUIFhIeHZ3jGP//8E4GBgShZsiRsbW0Ndppaasc2NjYWjRo1QqZMmZA1a1YAwLt376TO/eLFC4SHh6N8+fKwt7eHRqMxWV61udVkHzlyJA4cOIBHjx7B1dUVJUuWxJQpUyyWXc2Yh4SE4NmzZ/D29oajoyPy588PAHj9+rXZc6vNrhUbG4vixYtb9PmiJvexY8dw//59veUAsGDBAqlza/30008oU6YMnJ2dAQArV67ExYsXzZpbTXaNRoOVK1caHfNVq1aZJLea7GrHPCoqCv7+/siSJQs8PT0BACEhIWbPrTb79evX8fjxYzg6OiJnzpz45ptvTJZZbXa1Yx4fH4927dohS5YsyJw5MwDg1atXUueOiIhAeHg4qlatCicnJ6vpz0mTJuHw4cN4/PgxXFxcUKRIEQwZMsRi2dWM+YMHDxAaGgpfX184OjoiV65cAIDnz5+bPbfa7InVr1/favrzwoULRvflpvybKyP7c8OGDahSpQpcXV0BAMuXL8dff/1l1txqsufIkSPZ/vzxxx9NkltNdrVj/v79e9SpUwfZsmVDlixZAMBkf6+oya02+927d/H06VM4OTnBy8sLgYGBJsusNjv707y5b9y4wf40c241Y87+NE3utIz5u3fvdP2p3Z/fvXvXItmHDx+OMmXKwM3NDT4+PmjatCnOnDljsG6+fPmS/b4KFSqU7sx26d6CGa1evVrv61WrVmHfvn0Gy4sVK4alS5ciISEhQ/N07twZmzZtQo8ePVChQgWcOHECY8eOxYMHD7BkyRK9dYcPH47Zs2cjX758qFy5Ms6fP4/r16+jSZMm6Nixo7TZx40bp7dTPXbsGK5cuQIHBwdky5YNM2bMkDL3w4cP4eLiAmdnZ9SrVw+urq7Yu3cvnjx5grJly+q9qWDJ7Hfv3kXt2rV1f6Rpn9P29vbImjUr6tatCyEEgoKCEBISgqCgoAzNuG7dOmzYsAHlypWDr69vsuutXr0aGzZswO7du1G7dm2Ehobi+vXrAIC+ffuiSpUqAD6O7fjx47F7927cvn0b06ZNw9u3bzFmzBisXr0aU6dOhYODg5S5y5Yti71790Kj0cDPz8+kb56pzQ0AzZo10+X28/PDzp078eLFC73c79+/R8+ePVGpUiV8+eWX8PX1xfHjxzF+/HgAgBDC7NnVjHmpUqVQoEABlClTBh4eHrh79y6mTJmCJUuWYPjw4amOkSlzA8rGXJtduw+ZP38+Hjx4kO6c6cmuZsyrVq2Khw8fYvny5br7d+nSBfXr15c699KlS9GjRw8MHDgQX3zxBfr374+ePXvC3d3dZC8EMuK5EhERAVdXVwghYG9vDwA4c+YM5s2bhwIFCpgkt5rsasa8TJkyWLlyJSpVqoTp06fj/fv3+Prrr7F+/Xq0bdsWbdq0MVtuQPmYb968GadOnULr1q3RoEEDXLt2DfPnz0931rRmX716Nbp06QJ3d3fkyZMHly9f1i1PrFixYvjhhx9QsWJFHD58GKNHj4a9vT2++eYbrFixAuPGjdNN7siWu2nTptixYwfevHmDYsWK4cKFC+nOmdbcWolz+/n54c6dOwbZBw4ciJw5c2LYsGHw8/PD5cuXdZOssbGxZs+uZsxr1KgBT09PVKhQAdmyZcOzZ8/w7bffYunSpejduzc++eQTs+XWUjLmiftz69atOH78eLpzpie7mjFv3rw5Ll68iJ9++gmZMmUC8LE/W7ZsKXXupUuXYuLEiejYsSPatm2Lbt26oU+fPvD29sbjx4/NmltLyXNF+yGyxP15//59fPvttxbrT6Vj3qJFC6xcuRIFChTAhAkToNFo0L9/f2zfvh0//PADvv76a7Pl1lIy5idPnsSRI0dQp04dtG3bFo8ePcK8efMAwOiH+jI6e+PGjXH48GFUrFgRfn5+OHbsGG7dugWNRoPhw4ejZMmSAOTrTzW5ZerPZcuWwcXFRZc7OjoaO3bsQHR0NEaMGKHLDcjXn2rGXKb+VDPmsvWnmjGXqT/Vjnnu3Lnx4sUL1KlTB926dUNsbCwGDBiAyMhIi2Rfvnw5Pv30U/Tt2xcRERFYvHgx/P39sWfPHgQEBOjWnTt3Lt6+fat3f22HNmjQIP2hhRXr16+fUPMtABDjx483yWOfOnVKABBjx47VWz5kyBCh0WjExYsXdcsiIiKEt7e3aN26tYiPj7eq7ElpcwMQU6dOTfWxLJV76tSpAoC4cuWK0ezh4eFSZtdm9PDwEC9evNCt9+TJE5EpUybRpk2bDMsohBCPHz8WMTExQgghmjZtKvLmzWt0vUePHgl7e3vRr18/vdw1atQQuXLlEnFxcbp1v/rqK+Hs7Czu37+vlxuAWLx4sbS5nz17JqKiovTWk2W8hRCib9++AoBe7g8fPoigoCCD+0+cOFEAEF26dLF49pTG3BjtuH/33XcWzS2E8TFPLDQ0VLi7u4tJkyZJ9XxJacy7du0qXF1d9e5vDbk3bNggAIitW7dKl1uI1J8riQUGBgoA4uuvv7Z49pTGvFChQqJixYoiISFBtwyAsLe3Fy1atLBobiGMj/mTJ0+EnZ2dwb5v/vz5AoDo0KGDSXKryS6EEHfv3hVCCBEWFqbbVxgzY8YMAUCcOnVKtwyA0Gg0YtSoUdLmfvnypYiMjBRCCDFr1iyL7g+N5a5YsaLR7AcPHjRYtnLlSgFANG/e3BSxhRAZM+bGaJ8rvXv3Tk9cnYwYc63o6GiRL18+i/ensezJ5R4/frwAIMLCwnTLrCH38ePHhUajEXPmzNEtkyl3as+VxCZPniwAiB49eqQ3sk5GjHn9+vWFr6+veP/+vW6Z9vVe6dKlLZ7b2Jh/+PBBZMmSRdSsWVOv93ft2iUAiEaNGpkkt5rsZ86cEW/evNF9rf2bxcvLS1SrVk1vXZn6U01umfozaW4h/vmbNWlu2fpTzZgbY6n+VDPmWrL0p5oxl6k/1Yy5sf6ULfuLFy8UP8+1HWrs/SO1rOpUSGoYO/eVMY8fP0aPHj10p94oUaIEfvnll1Tvd/ToUQBAhw4d9JZ36NABQghs2LBBt2zdunUIDQ3F1KlTYWNjg3fv3qX4yWGZsidHo9Hg888/lza3dsbQ29vbYDs2NjYGn5KXKTsABAQE6H2SwsfHB1myZMHWrVsNZhpNlREAfH19dZ8CSsmOHTsQGxuLvn376i3/6quv8OjRI70Z8xUrVkCj0SBPnjx662bNmhUbN26UNvf/sXfmYVGV/Ru/BxjAYUdARBFxX3BfsTTNJcstl1xyweTtl6lFqaVtry1api0mvZppkiluaWqZ+1KKWWZauGRqCirKriyyM9/fH7znODszAnOeeft+rssrOXOY+Xj3nHPPzHOWOXPmoGXLlpU+p1Le0imDut6urq7o0aOH0XgePnw4ACAjI0MId8B05pa2Q93LIYmUua5748aN0bx5c0yYMMHs84qWeUJCAgoKClBeXm7xSAvRvKdPnw5XV1cMHz4cWq3W7KXVRB0r0jgvLi7G1q1bAUA+TV9pd8B05tevX8fZs2eNTrN2dXWVL0WlpLepzI8fP46ysjLcvHlTb98idfHZs2f1ntce7gCser8BAIsWLYKrqyu6dOmitzw8PNzu/WmL98yZM9GmTZtK1xPNu3fv3kL1py3u5vpTrVbbvT8B672BCve6detCq9Vi9uzZZtcTzX379u0AKo6gz83NNfvZTjTvcePGwcnJCTExMSAis58rRPMGjMf5+vXrAQChoaF664nmfvr0aWRkZMDNzU1vuXR2vYjeZ8+exZ07d1BcXCxfmhSoOFtQelwXe7h36tRJPrpZl549e8pnW0qI1J+2eIvUn6a83d3dAcDIW7T+tCVzkfrTlswld1H605bMRepPWzJfsmQJ3N3d8cknn1jsTyXda9eubTJzU6xfvx7h4eHo0aOHVV6WcKhLIVU3aWlp6N69u3w6YmBgIHbv3o3o6Gjk5ubihRdeMPu7xcXFAKD3ZgCoeIMAAL/99pu87MCBA/D29kZKSgoef/xxXLx4ES4uFdEXFRXJA1dEd0OkywX16NHDpjeC9vbu3bs33n//fURHR+Ott95C7dq1cenSJQAVp+pJ1xMV0d3UegDg7OwMoOKNXPfu3avd0RZOnz4NDw8Poy/eu3btKj/+4IMPIiUlBUVFRfDz8zN6jnr16uH06dNCeluL0t66j1vyTk1NBXBvvIngbinzrKwslJeX611SqG/fvkJ46z6u652ZmYn8/HwsWbLE7PUtlXY3lzkRwdvbGwUFBfK2WlJSIqx3bm4uMjMz4eXlhVdffRWxsbHyG7tz584J4637uLntc9euXSbvIaK0u6mxEhwcjKSkJMTGxmLIkCEoKioCUNFvMTExQnjrPv7ggw/K3Su955KQ9oW3bt2Sl9nL3Vq0Wi1u375t8v1KvXr1cPToUeTl5cn3vRDF21pEy9scSvbn/XDnzh2UlpbK3iUlJXbvT1u5e/cucnJysHz5cpPvfwFx3QGgUaNGyM/Pl7dV3S8aRPS+desWXF1dsXTpUsyfPx9ZWVkAgBMnTgjtbYh0WWFDRHQPDg5GZmYm3njjDURFRcnvE2/evCnfH0I0b3P9KZGamgqtVgsnJyfF3VNTUxEQECD/7Cj9aehtLUrnDcAqbxH701LmovenKW9H6E9LmYven4beBw8eREBAAHJzcxEYGIisrCwEBwcb/Z7S7tbsW6QOfe2116rnRat8zoOCWLqcUFRUlNEpIzA4RSU6Oprq1q2rd8kZIqKxY8eSj4+PfBkUU2zdupUA0Nq1a/WWf/bZZwSAIiIi5GVt27YljUZDGo2GnnvuOdq6dSu1adPG7Gn4IrkbMmjQIAJAy5YtE977nXfeoVq1asmnhEl/TCGKuzSmmzVrpncJiuLiYvLw8CAAtGXLlhpxNMTSaVeDBg2iRo0ayT9L3nfv3iUANHfuXCIi+vXXXwkABQQE6P0+AOrRowcBoKKiIuG8ifTHhLlLISnlbeik623oTkTUr18/AkBz5sxR3N2azN3c3PS2Wd3TrUXMXKvVUkBAgHxJoatXrwo1XixlHhERQd7e3rRp0ybasGEDRUVFEQAKDQ2l0tJSIb1PnTpFAMjJyYnq1KlDy5Yto/j4eDnz3bt3K+qt617Z9jly5Eh5vIs+VsaMGUPu7u5Gnap7CQrRMv/tt98IAHXo0EHvufbs2SNfxsne7rpYunyG9Jivr6/ecgD02GOPEQC6cOGCcN5E+mPc3KUclPS2dKkVw/6UToefMWOGEO6VeTdv3lxv++zZs6d8GVZRM5d6X0K08WLOu0uXLuTl5UXx8fG0ZcsWiomJIQDk7+9POTk5QnpnZ2fL/enp6UmLFy+WLy0IgD777DPFva3dPmfNmuUwY2X8+PGk0WhIpVLpbZ9jxowRwttU5hkZGaRSqahp06Z6z3XhwgXZX3JVwp3oXu+rVCq9yw2L3J+WvInE7U+J4cOHE2B8eWdDd8lThP4ksi5z0fpTwlLmovYnkeXMRe1PCVOZS/3p5uZGKpVK7s+BAwcSABo0aJC8rpLuR44cMZm5IVKHnj9/3urntsT/7KWQKoOIsHXrVgwZMgREhMzMTPnPI488gpycHJw6dcrs7z/22GMICwvD7Nmz8c033yA5ORmbN2/Ga6+9BhcXFxQWFsrr5ufno6CgAJMmTcLSpUsxYsQI9OrVCwCwceNG+Uh6Ed0NkW5gO3r0aJuclfBu2LAhevXqhc8//xxbt26Vj2yUbiQksvvFixcRHR2N8+fP4+zZs5g0aRIKCgoAwOz/n6o62kJhYaHR6bzAvdPGJEfpv6aO4JaOgCkoKBDO2xpEyFv3cXO8++67OHDgAIB7/04R3C1lvnv3buzatQsffvghgHs3/RLBW/dxiS+//BK3b982eWaOhAjupjLv1KkT/Pz8MHr0aIwdOxZffvklgIrL3mzZskVIb+loFq1Wix07duDZZ5+VL81Xq1YtzJ8/Xwhv3cdNkZubi++//x6PPfaY3nIR3E2NFWdnZ6jVakRFReHrr7+WT+fdtGkTLl++LIS37uMA0LFjR3Tr1g1nzpxBfn4+kpKSsHv3bjzzzDMA9G8Gai93axGtP6sTEfM2xfr16+Ub20uXpxTdPS4uDnv27MGyZcsAVIzx8vJyYb0PHz6M5ORk+Pv7m11HVPdWrVrB398fTz75JEaOHIklS5YAALKzs7Fs2TIhvXX7c9WqVZg9e7b8mS4gIMDu/Xm/aLVabNy4ER06dNBbLqq7k5MT1Go1Ro0ahQ0bNmDdunUAgG+++QY///yzkN4BAQEYPXo0Ll++jNzcXFy5cgVHjx7FmDFj5HUKCwsVdZd6Mjw8HC+//LLRclH705y3NSiZd3p6Ovbt2wcAlXqL1p/WZC5if1rKXPT+tJS5yP1pLnOpP4uLi1G7dm25P7///nsAwJEjRwAov40++eSTle5bdDvUmkt/W8M/9lJIGRkZuHPnDj7//HN8/vnnJtdJT083+/vu7u74/vvvMXr0aIwcORIA4ObmhkWLFmHBggV617qSTksaN26cyec6fvw4mjZtKqS7Lvn5+bh69SoA6F3/X0TvjRs34v/+7/9w8eJF1K9fHwBw6NAh/Pnnn5gzZw7GjRtn07/B3pm/+uqrWLx4MdasWQMA6Ny5M9q0aYPExESz/3+q6mgLtWrVkk+R1UW6NIY05qX/konr5klf6OTn5wvnbQ0i5K37uCk2bdqE119/HdHR0fKbO0AMd0uZ9+nTBwDw6KOPYtasWfjhhx/w6aefYvTo0Yp76z4OVHw5/MorryAiIsLkJW0kRM/cFAcOHMDDDz8snLf0XxcXF3Tr1k1v3ebNm+PEiRO4deuW4t66j5ti69atKCoqwvjx47Ft2zZ5uahj5YcffkBZWZk8+QQAU6ZMQXl5OV577TXExsYq7q37uMTWrVvRsWNHpKenIzw8HM7Ozpg5cyYWL14s32/JnplbizX9WVhYKJy3NYiYtyFHjx5FdHQ0HnnkEezdu1deLrp7ZGSk/Pdp06YhMTERr7zyCl5++WXhvMvKyvD888+jcePG8pg2heiZG+Lh4YEDBw5gypQpwnnr7htHjRql91hERAR++OEHnD59WjhvQ3788UekpKTgxRdflC+rCog7Vn755RcUFBRg48aNcHKqOK5zwoQJ8PLyQkxMDL777jshvVesWIGffvoJ169fR+PGjQFUeP/xxx8AAE9PT8Uyv3v3Lnbu3Amg4r5Lpr57EbE/LXlbg5J5Dx48WD7Yy5K3aP1pbeai9aelzEXvz/sd50r3p6XMpf2KSqXSu8yatE/Py8vDtWvX4O7urqh7Xl4eEhISLGau26HVxT92YkG6V8CECRMQFRVlcp22bdtafI7WrVvj7NmzOH/+PG7fvo1WrVqhVq1aePHFF/HQQw/J64WEhODcuXMmbyQMALdv3xbWXZft27db3HGJ5L1s2TJ06NBBnlTQpaCgAKdPn0a/fv2EdAeABQsWYPbs2Th37hx8fHzQpk0b+fmbNWtWY47WUrduXRw+fBhEpHc0iHS96pCQEHk9ACgvLzd6jry8PPj7+8s3phHJ2xpEyFvClHdRUREmTZqEQYMG4bPPPtObWBDB3ZbM69ati/j4ePlDsEiZf/DBBygpKUHDhg1x8uRJJCUl4caNG/J6d+7cQUlJicNlrtFokJ2dLaS39F/pjZwuHh4eKC0tlY8qEWmsGBIfHw8fHx/5RogSImZ+5coV3Lx50+SEfIMGDXDs2DEhvCV0M69Xrx4effRRHDhwABs2bEDTpk0RHByMxYsXy/8ee7pbi7+/P5ycnMz2JwAEBQUBEMvbGkTMW5eSkhIMHToUERER2LJlC7y8vOTHRHc3JDw8HPHx8fJNHUXy/uqrr/DXX3+hX79+SExMRFJSkt7jd+7cQUFBgcNl7uPjY/f+tBZpvwLcu3ebhPRFifS5VCRvQ+Lj4+Hk5IRx48bp3bBUxMxLSkpw6dIleHt7G71vadKkCU6ePClP5ovkDVSM5YcffhgHDx5EfHw8wsLCEBYWhnXr1kGj0cDX11e+Hr093UtKSjBixAhkZmYCqJgU00XU/qzM2xqUGOOSd2JiIh577DH5xrvm1hWpP6uSuZL9WVnmIvdnVTJXsj8ry9zf37/Se+Pevn1b/s5XKfe9e/dWmrluh1YX/9iJhcDAQHh5eaG8vNymL5gNUalUaN26tfzzrl27oNVq9Z6zU6dO2L9/P1JSUtC8eXOTLqK66xIfHw+1Wi3P4NmKPb3T0tIsXpbE1gkSJTL38/PTu+HnzZs34ezsjBYtWtSoozW0b98eq1atwp9//olWrVrJy3/55Rf5caDiCx03NzeTR5ampKSgffv2Qnpbgwjeuo/rkpGRgfT0dERGRmLz5s1GN14Twd2WzEtLS5GTkyOEt+7jAHDt2jXcvn0bO3bsAFDxJlSXTz75BJMnT0abNm0Ud7cl84KCAgQGBgqRuaF3SEgI3N3dTXZRXl4e3N3dER4erri37uOGlJeX4/Dhw5g8ebLRJX1EzDwtLQ2A6aP/tFotysrKhPDWfdwQFxcX9OzZEwBw/vx5ABU3jQPsm7m1ODk5wc/PT/4SRJeUlBQ0atTIruO8OhExb4m8vDykpaWhSZMm2LVrl9ERXyK7m0KJ/rSWa9euobS0FLt37wZguj979+6NIUOGCOduiTt37iAiIkLIzJ2cnODv74/MzEyUlJTIZ20B975wbdasmXDeukiXmejdu7fRxL2ImWdlZYGIzPanVquFv7+/cN66ODs7y5dxls7OVao/tVotJk2ahIMHD2LAgAHYs2eP0Toi9qc13tagZN6bN2/GoUOHzK4rWn9WNXOl+tOazEXtz6pmrlR/WpO5k5MT2rdvL39GMoW9PzsDxu7mDhKXKC4uNtuhVeEfe48FZ2dnjBw5Elu3bsXZs2eNHs/IyLD5OQsLC/HGG2+gbt26erM/0rUrdY8YlnBxcUHv3r1teh17uus+54EDB+Q3EfeDPb2bNWuG06dPy/eE0MXJycnmWUIlMtdl06ZNyMrKMnm0S006mmPYsGFQq9XyNQglPvvsM9SrVw89evSQl4WFhaGwsBDXr1/XWzc7OxtPPPGEsN6VobS39AHF0PvPP//EwYMH4eLigp07d5q8DIvS7oBx5mVlZSgpKTH5HOnp6ejcubPi3qYyf/7557Ft2zb06dMHgYGB2LZtG1asWCH/zpgxY+TLr4iWeVFRkcWJ4oEDBwrpDVS8gS4vL8f+/fv11r1w4QIefvhhqNVq4caKLnfv3oVWq8X48eONHhMx8yZNmsjehl+OJCcno0OHDop7V5a5hFarla872rlzZwD2zdwWwsLCUFJSgpMnT+otv3r1qt37szoR1Ts1NRX79u2DSqXC3r17TR74I6q7dMSzIVevXrV7f1rL2LFjjfpT97JwY8aMQbdu3YR0B8xnXlBQYPf+tAXpCyjpcqsSiYmJaNWqFUJDQ4X0lpAuYaN0f1pLUFAQ1Go1CgoKjN7n/vXXX2jRogU8PT2F8zbHK6+8AgDo3r07APtn/txzz2HTpk1YtmyZfHkmU4jWn9Z6V4aS3iNGjDC7noj9aW3movWnNZmL2p9VzVyp/rR2nI8ZMwZEJJ8ZD9z7twQEBCAkJERYd4ldu3aZ7dCq8I89YwEAFi5ciMOHD6Nbt254+umn0apVK2RnZ+PUqVM4cOAAsrOzLf7+6NGjERISglatWiE3NxerV6/GlStX8P333+ud9tWhQwdMmTIFq1evRllZGR566CF59u6ll166r5kie7lLbNq0CWVlZWjWrBn++usvm33t7f3SSy9h9+7d6NmzJ2bMmIHatWvju+++A1BxTWjRM+/Xrx8GDBiA2rVr4+eff0ZcXBxCQkLkywbVlGNiYiK+/fZbAMDly5eRk5OD+fPnAwDatWuHIUOGAADq16+PF154AYsXL0Zpaal8A/KjR48iPj5e7/Tqtm3b4vLly+jTpw9iYmLkHXFQUBCeeuopYb3z8/Pl59F9U3rkyBGsXbsWEydOVMy7S5cu8o2CFi1aJHvn5eXhkUceQXFxMXx9feV1JHQnd0TLPD8/H19//TXc3d3x0UcfwcPDA2fOnAFQcT+SN954Q1Fvc5l37NgRHTt2xPbt23HlyhU8/vjjeqejtmjRAj4+PkJmnpqaKme+dOlSAJCvhdq4cWMMGzZMSG8AaNOmDS5evIiRI0di5syZcsZarRbvvvuuot7mxooud+/eRUhIiNkDC0TLPDAwEE2bNsWlS5fQt29fjBgxQj4SsKysTP6iQcTMY2JicPz4ceTl5WHp0qVYv349Tpw4AQDyuLGnOwCsXbsWycnJKCgokJdJ606cOBFhYWEAKvYfiYmJGDRoEGbPni2/B/Dw8MCsWbOE9S4pKZGf59ixY/K6R44cwaeffooZM2Yo6n3z5k3ZXdd74MCByM/Ph7e3NxISEpCQkCA/x99//y3/XcTMd+zYAWdnZyxatAh+fn7ytlxeXo6FCxcq7m0q8xYtWqBFixZ6/alLixYt5Etqipj5li1b5Pcs7u7u8nipU6eOfIN4Eb2bN2+O33//HdOnT8fFixfRoEEDAEBOTg7Wr1+vuLe57VPi7t27cHNzk+9ZZ4homTs7OyMiIgKnT59G9+7dMWnSJPkSPXl5eXj99dcV9zaX+cKFC3H06FHk5eVh+fLl2L59u3xT03r16tk98yVLlmDZsmWIjIyERqORv5OQboY9fPhw+ZJeIvWnLd4i9aeh97p16/Tcdb1F609bMhepP63NXMT+tCVzkfrTlnH+zDPP4K233kJWVhZeeuklNGjQAGvXrgUADBgwQH5tJd110XWXiI+Pt9ih9w05MNOnTydz/4SoqCgKCwvTWwaA5s2bp7csLS2Npk+fTqGhoaRWqyk4OJj69u1Ln3/+eaWv//7771OLFi3I3d2d/Pz8aOjQoXT69GmT65aUlNCbb75JYWFhpFarycfHx2HciYi6d+9OQUFBNG3aNIfx/uWXX+jRRx+l4OBgvcxLS0uFdZfG9IABAyggIIDc3NyoRYsW9N5779HEiRNr3DEuLo4AmPwTFRWlt255eTm9++67FBYWRk5OTgSA1q1bZ/ScUVFRFBISQgMGDCCNRkO+vr4EgGbNmiW09yOPPGL2OR966CFFvV1dXcnf399oW7x69arZ5wNA7dq101tfpMyLi4upZcuWpFarydvbm9RqNYWFhREAiomJUdzbXOYSuvsQ3f8PIm+ft2/fpkaNGpGLiwtpNBpyc3Oj1q1bEwB6/fXXhfUmqsi7Xr16NHz4cPL29qZatWoRAPrXv/6luHdlY+Xxxx8nADRz5kx5mehjhYho4sSJ5O/vT+3btydPT0/y9PQkADRp0iTFvS1lHhcXR35+fqRSqcjLy4v69u1Lhw4dUjTzhx56yOy6hw8flteLioqi+vXr06hRo8jb21vO/LnnnhPae+TIkWbX030fI5q3pf40fP8lmnu7du3I1dWV/Pz8yMXFhUJCQggATZ06VWhvIuP34Er3p7XuTZs2JbVaTV5eXqRWq6lJkyYEgObOnSu0d1RUFIWGhlJUVBT5+/uTm5sbAaDx48cL7U1E9OSTTxIAGjFihLzMEcZKVFQUBQQEUNeuXcnX11d+z/LEE08I7b1z504KCAgglUpFGo2GunfvTps3b1Ys86ioKIv76atXr+qtK0p/2uItUn/a4m1pPSX60xZ3kfrTFm9pfVH60xZ3kfrT1szHjBlDHh4ecn9269bNITInIsrJySF3d3e9Dq0uVEQmLvjHMAzDMAzDMAzDMAzDMAzDMAxjgn/sPRYYhmEYhmEYhmEYhmEYhmEYhrEdnlhgGIZhGIZhGIZhGIZhGIZhGMZqeGKBYRiGYRiGYRiGYRiGYRiGYRir4YkFhmEYhmEYhmEYhmEYhmEYhmGshicWGIZhGIZhGIZhGIZhGIZhGIaxGp5YYBiGYRiGYRiGYRiGYRiGYRjGalyUFhANlUpl9jEisqOJbTiqN+C47o7qDTiuO3vbH0d1d1RvwHHd2dv+OKp7qEqFGwDqA/gBQGMAfwN4CMANgb0Bx82cve2Po7o7qjfguO7sbX/+VqnQG8ANnWVyJwns7siZS+5SzukABgLIhdju/wuZm0Jkd/a2P47q7qjeAAAd978BvU4S3t0APmOBYRiGYRiGsRs/Aniha1e9SYXeAFIUdGIYhlEKbwD1lJb4h9EYFV9u1//vz7oT3UzNoZtzEAAvRW0YhmHEYCL0J7odDZ5YYBiGYRiGYexGIwAfnzihN6ngyG+mGYZhqsIeVEy41jdYbvgzU338jYovt3/18MAAT0+9iW6mZvjP+PF8QAHDMIwJ1sKxO19FjnaORQ3jqKfSOKo34LjujuoNOK47e9sfR3V3VG/Acd3Z2/44rLuOdw8Ax3UeEtobjps5e9sfR3V3VG/Acd3/VqmMJlr5sjw1S6hKhZ/UaoSWlsrLpPyvC+zuyJlL3W/qgAKR3R05c0d1Z2/746jujuoNVHT/RFRMKhi+BxDd3RA+Y4FhGIZhGIZRBEc/QodhGKaq9Ma9I+h/ABAJvixPTXMDwCSDL6Qc/VIUjgLnzDAMU9H9x2H8HsARL43IEwsMwzAMwzCM3fgbFWcq6L6J5skFhmH+qdyA/hcLP/33v1ed+KN6TVEfwKqSEr1lPNFtHzhnhmGYexOsuu8B0gHkKSVUBfjdigFEZPaPyDiqN+C47o7qDTiuO3vbH0d1d1RvwHHd2dv+OKp742vX8BMRGl+7BjRqhMYArjdqBLp+XWm1SnHUzNnb/jiqu6N6A47rTkS4ToTGx47pLQ8/elQhI+tw1LyBis5pDACNGgHHjul1kcg4cuaGOdO1aw7h7siZO6o7e9sfR3V3VG9A3/06ERpfv47IO3eQ4wDuhvA9FhiGYRiGYRiGYRiGYRiGYRiGsRo+Y4FhGIZhGIZhGIZhGIZhGIZhGKvhiQWGYRiGYRiGYRiGYRiGYRiGYayGJxYYhmEYhmEYhmEYhmEYhmEYhrEanlhgGIZhGIZhGIZhGIZhGIZhGMZqeGKBYRiGYRiGYRiGYRiGYRiGYRir4YkFhmEYhmEYhmEYhmEYhmEYhmGshicWGIZhGIZhGIZhGIZhGIZhGIaxGp5YYBiGYRiGYRiGYRiGYRiGYRjGanhigWEYhmEYhmEYhmEYhmEYhmEYq+GJBYZhGIZhGIZhGIZhGIZhGIZhrIYnFhiGYRiGYRiGYRiGYRiGYRiGsRqeWGAYhmEYhmEYhmEYhmEYhmEYxmr+JyYWJk+ejIYNG+otU6lUePPNNxXxsRZH9QYc191RvQHHdWdv++Oo7o7qDTiuO3vbH0d1d1RvwHHdHdUbcFx39rY/juruqN6A47qzt/1xVHdH9QYc15297Y+jujuqN+DY7jWJsBMLKpXKqj8//PCDXXz27duH6OhoREREwNnZ2Wgw3a93UVER+vTpg4CAAPj6+gIA/vjjD7t7X7hwwSb3q1ev4tatW3B3d0dgYCCio6OrzdlWd1szLy8vx+jRo+Hr6wtvb28AwO3bt+3uffPmTavdv/rqK5w4cQKpqalwd3eHSqVCUlJStTnb6m5L5snJycjIyECjRo2g0WjQvHlzABVjX2Tva9euIS0tDSEhIXBzc0P9+vUBAOnp6Xb3tmWsGO4T+/fvD5VKVW3Otrrb4v37778jOTlZbzkAzJ8/3+7e95P53bt3ERkZCQ8PD3l/fvXqVbu72+K9ZcsWk5m/9dZbaNq0qbDegDj9aetYceT+LC0txcCBA+Hp6Ql/f38AFePe3t62uC9fvhw///wzbt26BbVaXSP7Q1vcrfU+dOgQLl++jPT0dISGhsLDwwMREREAgLKyMrt72+I+e/Zs7NmzB9evX4ebmxvCw8Px1FNPVZuzre7325+lpaVo1aoVAOCnn34S2jshIcHkvvzTTz+1u7et7kSEvLw8tG/fHrVq1ULt2rUBAKmpqXZ3t8V7zZo1Zvuzf//+dvW21T0pKQm3bt2Cr68vateujYceeqhafO/H3dbtMy8vDy1btoSbmxvq1asHACgpKRHeW5T+TEpK4v60s7ctmXN/2t9bpP60Zaxwf1aPt62Zi9Sfltw3btxotP6nn36q158zZ86sth5yqZZnqQHWrl2r9/NXX32F/fv3Gy1v2bIlVq5cCa1WW6M+69evx6ZNm9CxY0eEhISYXe/RRx/Fjz/+iC5duqBRo0ZISEjApUuXoFKp8PLLL8ul1rJlSwwdOhRr1qxB48aN8eabb0KlUmHGjBnYvn07Pv74Y7z44ot28161ahU0Go3sXVhYiB07dqCwsBBz5syRvQHgl19+wZEjR9CnTx+MGjUKN27cwCeffAKgesvaWvcFCxZg7dq1aNasGWrXro3jx4/jwoULAIAhQ4Zg9OjRACoy//jjj9GlSxf8+OOPePXVV6FWqzFz5kzExcXh3//+t7wztod3ZmYmWrRoIXuXl5dj9+7dyMjI0PMGgKysLFy4cAEtW7aEq6srfv/99yp7VsXdlswTExMRHh6OESNGoEGDBjhz5gwuXryIVatWYd68eahVq5aQ3j179kTt2rXRuXNnBAQEIDU1Fa+//jpWrlyJZ555Bu3atbObty1jRXef+M033+D48eNV9qyKuy2ZDxkyBH/88QeWL18OT09PAMDEiRMxbNgwu3vbmnloaCgyMzPRp08fTJ48GaWlpXjuueeQm5trd3dbMv/yyy+Rl5cHtVot//7EiRMBAAMGDBDWW6T+tGWsiNafuu+pioqKMGPGDBQXF8PNzQ2rVq2SH2vZsiXmzZuHnTt34vLly3j33XeRn5+P1157DWvXrsWCBQvg6upqN29d96KiIrz00kvIzc2FVqs1ep/4+++/4++//0abNm1w9+5dXLx4scqeVXG3NvOGDRvi2LFj6Nq1K4YOHYqgoCAcP34c586dw7p16/DOO+9Uy5c8NZH5gQMHMGDAALRu3RqBgYG4evUqVq5cCaDiS8HqoibGue5nitjYWFy7dq3afGvSu0ePHrh+/Tq++OILefnEiROr7QO6Ld667pWNlZYtW4KIkJOTg8cffxwzZszA3bt38cILL1Trl641kXlcXByISIj+1HWvLPNjx47hxx9/xMCBAzFs2DAUFRXhyy+/BAD8+eef1eJti7stmQcEBCA7OxsPP/wwYmJicP78ecTGxmLTpk1499137er90UcfYebMmejevTvat2+PhIQEnD17FlOnTkXz5s0REBAge4vWnwBkbwCy+8cffyx7A+L1p7WZi9ifgHWZi9aftoxzkfrTFm/R+hOwbqyI1p+2ZC5afwLWZS5af0qMGzcOjz32mN6yyMhIvZ/nzJmDRYsWYdSoUXr9ee7cOezdu7fq0uQgTJ8+nWzRBUDz5s2rttdPSUmhkpISIiIaNGgQhYWFmVzv5MmTlJeXJ/8seQcGBtIDDzygt27//v0pJCSEioqK9Lz9/Pyobdu2inoTEUVHRxMAPe/i4mLy9fWlXr16kVarlZd/9913BIAGDhxYLd62uBsiZT548GDy8PCgsrIy+bH333+fANCJEyfkZQBIpVLRK6+8oqi3rruhd1ZWFuXm5hIR0eLFiwkAXb16VbFxbs7bVOaHDx82Wh8AAaCVK1dWh3aNeJtCGivPPPNMVZWJqGbGikRhYSE1bNiQ3n77bTlv0cfKvHnzCABlZGTIy0TxJjKf+fHjx0mlUtFHH32kt74o7vczzgHQsWPHqqpMRDXjLVJ/WnLX9Ra9P+fMmUO+vr6ytyHPPvss1apVi5KTk+Vl0lhZsWKFot7NmzenZs2amXyfmJqaSgUFBUSk/15ShO3TUubFxcUmt0Ep8/379yvqbSlzU5w8eZIAUN++fauiq0dNjHOJtLQ08vHxkTu0f//+1aVdI95RUVFGy0UZ45bGyqZNmwgAffPNN3rLRXG3ZqzoIm2f169fr4quTE1k3rRpU+rSpYteD+Xk5BAAatasWbV4V8XdXOY3b94kFxcXmjhxot5yKfNvv/3Wrt7S57DFixcTkeXvKkTqT0NvS+6i9ae1mYvWn7Zkbgol+9OWcS4hQn/a4i1Sf9oyVkTrz/sZK7oo1Z+2ZC5af5pyN4W5/oyNja22/hT2Uki2YOo6V6ZISUnBlClTUKdOHbi5uaF169ZYvXq1Va8REhKiN6Nmjk6dOslH2urSs2dPo1ms06dPIyMjA25ubnrLNRqN3lHcSnm7u7sD0J99O3v2LO7cuYPi4mKEh4fLywcPHiw/ros93M3RsGFDFBQU6J0eu2jRIri6uqJLly5664aHh2Pz5s1CeAMw8vb398dzzz0nzDg3h6nMv/zyS7PeumNLNG9z+xW1Wo07d+4I4Q0YjxWgwr1u3brQarWYPXu22d8VLfPt27cDAIgIubm5ICLhvAHjzJcsWQJ3d3d88sknICLk5+eb/V3RMjc3zn19fdGjRw9hvUXqT0voeovcn5cuXcLHH3+MBx980Ow6cXFxUKlUaNCggd5yf39/xfpT8v7oo4/MHn1Yp04dPPvss8L1Z2WZu7q64vPPPxeuP63JHDDet0h/N7wMokiZ63rPnTsXzZs3x4QJE0yuJ5p3QkICCgoKUF5ebvFMOdHGykcffYSAgAC8+OKL0Gq1Fo+yFC1zwzFeXFwMAAgLC5Mvn6mUt6XMc3NzcevWLb0eki4Na/haImV+/PhxlJWVmT2yUveyD/bu/rt376K8vNzs4yL2p+Rt6TJSovYnYDlzUftT8q7s0l0i9qfkbmmci9if1niL2J+St6WxImp/Su7WjBUJEfpT8raUuaj9WZm71J9jx47VWy79bOqySbYi7KWQqpu0tDR0795dvlxCYGAgdu/ejejoaOTm5uKFF16o0ddPTU3VO40GAIKDg5GZmYk33ngDUVFR8hvAmzdvYunSpUJ4A9DzljZ6FxfTQyc1NRVarRZOTk52dy8sLMTdu3flQoiLi0NkZKT8JZNWq8Xt27fh4eFh9Lv16tXD0aNHkZeXh4KCAkW88/Pz5ct+6HrbgmiZV4Y0tkT2vnPnDkpLS+VrFZaUlKBv376Kelc2Vu7evYucnBwsX77c7P8LkTNv1KgR8vPz5W1V94t6ETM/ePAgAgICkJubi8DAQGRlZSE4ONjouUTOXOL06dMAgDZt2gjtLWJ/VjZWRO7PF154AX369EFYWJjJx1NSUlBUVAQ/Pz+jx+rVqyePG6W8H3vsMcycObNKzyVa5pWhVH/akrlWq0V6ejquXbuGt99+GwD0PoyJmnlJSQnWrFmDhIQEk1/OiupNRPD29kZBQYG8rep+yBRtrOTm5uLEiRNo3rw5bt26BR8fH+Tn5+uNEaXdbdk+d+3aBQBo27at4t6Wts/evXtj8+bN8PPzQ1JSEoqKihAbGwsA6Natm+Lu5jKXOtTchMlvv/2miPdbb72Fl156Sf553759epfyELU/JW+VSmX0HYWtiJZ5ZSjVn7ZkLlp/Wpu5aP1prbdo/VnZWBG5P+9n+xShP63ZPkXtT133Tp06YcGCBXqZS/1p+B2ARqMBcK8/q0SVz3mwE5WdvmR4eggMTgGKjo6munXrUmZmpt56Y8eOJR8fH/k0P2u4n0s5qFQqeuONN/QeGz9+PGk0GlKpVPKpPwBozJgxinsTEQ0fPpwA6HlnZGSQSqWipk2b6j3XhQsXZH/J1d7u7733nl6Offv2pWvXrum5AyBfX1+93wNAjz32GAGgCxcuKO4NQM9bQhrnli6FpLS7Yea63rpI28TFixeF927evLneuj179qTy8nIhvM2NlbCwMHJzc5N/ltYVfax06dKFvLy8KD4+nrZs2UIxMTEEgPz9/SknJ0cIb8PMs7OzCQC5ubmRSqWixYsX06ZNm2jgwIEEgAYNGiSvq7S7NdvnrFmzCABNmzZNaG8R+7OysSJqf+7cuZNcXFzo3Llzepdw0uXXX38lABQQEKC3HAD16NGDAFBRUZFi3kQk76tNIY1zS5dyEC1zXW9dAJCrqyvdvn1bUW+iyjPX3RZq167tMJm7urrSuHHjiOjeaea6l3IQ0TsiIoK8vb1p06ZNtGHDBjn/0NBQKi0tVdSbyPRYOXXqlNyfTk5OtGzZMoqPj6euXbsSABo/fry8roiZG26fI0eOJAA0Z84cxb2JzG+faWlpVLduXb3tMyAgQPjt87fffjP7OQ4AeXp62tU7OTmZBgwYQMuXL6dvv/2WHnzwQQJATk5OtHPnTnk90frT0HvJkiXk6elJAPS8JUTqT2sz1/XWRan+vJ/MRelPWzMXpT9t8RapP60dKyL2Z1W2TyX705btU7T+NOXeoEEDo8yl/nznnXf0fn/Pnj16/VkV/icuhVQZRIStW7diyJAhICJkZmbKfx555BHk5OTg1KlTNfLahYWFACpmmF9++WW9x5ycnKBWqzFq1Chs2LAB69atAwB88803+PnnnxX1Tk9Px759+wBAzzsgIACjR4/G5cuXkZubiytXruDo0aMYM2aM3r9ZCfdx48Zh//79ejfakfLX/bup2XPpCNKCggLFvNevX4+mTZsaeVuLiJmbYv369QAqjuRt2rSp8N5xcXHYs2cPli1bBqDiBqvl5eWKelsaK4cPH0ZycjL8/f3NPo+ombdq1Qr+/v548sknMXLkSCxZsgQAkJ2djWXLlgmZuXQ2RXFxMWrXro3Zs2dj9OjR+P777wEAR44cASBu5rpotVr5VMjAwEChvUXsz8rGioj9WVJSghdffBFTp05Fq1atzK4nWn9a620tImZuCunmpP369YOvr6/w3nXq1MGuXbvw4YcfGl0CRFT3y5cvo7S0FO+//77Jx0X17tSpE/z8/DB69GiMHTtWvpng9evXsWXLFiG9dfszKCgIzz77LJ588kkcPHgQgDL9eb/bZ25urtz70qVkRfXWaDTw9vaGh4cHvv76a6xevRp169YFUPF+S1T3jh07IiAgADk5OYiLi0NSUhJ2794NoOI9gb37s0GDBti7dy+mTp2KIUOGoF27dgAq3j/NmjVLXk+0/jT0jomJkd+H6Hpbi4iZm0LJ/ryfzEXpT1syF6k/bfEWqT+tHSsi9uf9bp9K96ct26do/WnK/fTp00aZd+zYEd26dcP777+v15/PPPMM1Gr1fX33aESVpybsRFXOWEhLSzM6itDwj+FNTyxh7ZH/+fn5FBQURADozJkzRo83a9aM1Gq1fPSz5O3v709du3ZV1LtLly7k6upqMvM7d+5QaGionseECRPkv9++fVsxd6J7Y+Xpp5+m0NBQeUbQmjMWjh07ppi3rruut0RlZyyImLmuNxHRkSNHyN3dnYB7Z8I4grcE/nsE1axZsxT11nXX9S4tLaWIiAhq3Lix3nNJPo40VnTdPTw8qG/fvkJmLu1XVCqVSXcAlJyc7BCZHzp0yGHGiqj9aehu6C1afy5cuJD8/PwoKytLz/t+zli4du2aYt5EVTtjQcTMdb2JiDZu3CifoSOCN5F1mUtcvnyZANCjjz6quLu5zHNycsjd3Z18fHzkZYZHXIroTWS+PwFQdHS0kGNF2q94enqadHdycqLS0lKHyHz16tWK9qct2+fAgQOpfv36es+VlZVFAKhVq1aKu1vK/IknniA3NzfZwdnZmQBQSEgI+fj4CPGeZe7cuQTcuwGpaP1pyV3XW0Kk/jTnbZi5rjeR8v1pyd1S5hJK9qc5b8PMRetPa72JxOpPS+6m9isi9ac578oyV7o/LbkbeovWn+YwlfmNGzfogQce0OvPl156ibp27aq33d4v/4h7LGi1WgDAhAkTEBUVZXId3et5VQclJSUYMWIEMjMzAQARERFGj1+6dAne3t5wctI/caRJkyY4efKkfIMeJbwTExPx2GOPyTdT1cXHxwcPP/wwDh48iPj4eISFhSEsLAzr1q2DRqOBr6+vfD16e7obMmrUKKxcuRJHjhzBI488An9/fzg5OZm8kUxeXh4AICgoCICy3kDFDLnkbS1KjHNDDDPX5Y8//sDQoUMRERGBkydPyuNedG9DwsPDER8fL98UWaSx8tVXX+Gvv/5Cv379kJiYiKSkJL1179y5g4KCAofL3MfHB9nZ2UJ4A/qZ+/v7y0dXmOP27duoU6cOALEzj4+Ph5OTk5wzIOb2KWp/msJwXy5Sf+bk5GD+/PmYNm0acnNz5T8AQERISkqCRqNBUFCQfDSOuf709/eXbzKmhDcAlJaWAoCet7XYa5zbkrku+/fvx6RJkzBo0CDs3LlTCG/AtswbN24MAEhMTFTc3VzmH3zwAbRaLTw8POT+vHHjBoCKo46TkpLkfY5I3pbQaDR27U9bxkpISAgAmO1Q6WaUIo4VQ+Lj4+Hj44OcnBw9f6W8AdOZX7lyBXv27EFkZCRu3rwpP4d0luv169cVd7eUuUajQXBwMPbv34/U1FQ0bdoUdevWRW5uLlq2bCnEe5bQ0FAAFUev1q9fX6j+tAbJ21pEzFwXpfvTGirLXKn+tIRh5iL1py3elrB3f1qD5C1af1qissyV7E9rkLxF609LmMq8Xr16SEhIwKVLl+T+DA4ORkhICJo1a1bl1/xHTCwEBgbCy8sL5eXl6NevX42/nlarxaRJk3Dw4EEMGDAAe/bsMVonKysLRAQiMvn7Wq0W/v7+inlv3rwZhw4dsri+s7MzevXqBaDiC0ug4qargP0zN4V0So+0k3JycoKfn588iaBLSkoKGjVqhPDwcMW9JXR3rtYgYuYSZWVlGDhwIIKCgrBr1y69D2Uie5uitLQUOTk5QnhLSN7Xrl1DaWmpfGq44Q2cPvnkE/Tu3RtDhgxR3N2WzO/cuYOIiAghM3dyckL79u3xyy+/mF03MDBQCHdLmRcXF2Pr1q3o3bu33r5fRG8R+9MSpvIWoT9v376N/Px8LFq0CIsWLdJ7rKCgAOHh4Rg2bBi2b9+OevXqwc3NTb75ly4pKSlo3769EN4A9LytRQR3w8wliouLMXz4cHTu3BmbN2+Wb7QmijdgW+bSGBLB3TDza9euoaSkBDdv3jTqz4SEBISHh+PkyZPCeVuioKDArh1ky1gJCQlBcHAwcnNz4eHhYbSus7MzvLy84Onpqbi7pcxv3bqFw4cPY/LkyVi9erW8XMTM09LSAMBkfwL3vhARwd1S5k2bNpUvOQhUXBakX79+QrxnuXLlCoB7l5QUqT+tQfK2ZX2l3Q0zlxChP63B2szt3Z+WMMxcpP60hLmxYgp796c1SN6i9aclLGWudH9ag+QtWn9awlLmuv15/vx53Lp1C5MnT67ya/4j7rHg7OyMkSNHYuvWrTh79qzR4xkZGdX6es899xw2bdqEZcuWyTPMhgQFBUGtVqOgoEDvjvMA8Ndff6FFixbw9PRUzHvEiBE2/e4rr7wCAOjevTsA+2Zu7rm++OILqFQqdOzYUV4WFhaGkpISnDx5Um/dq1ev4oknnhDCG4CRtzWI4G4q88LCQqSlpcHJyQl79+412sGJ6i0d8WzI1atX0blzZyG8Af2xMnbsWGzbtg19+vRBYGAgtm3bhm3btsnrjhkzBt26dRPC3ZbMCwoKMHDgQCG8AePtc8yYMSAi+XqXwL1/S0BAAEJCQoRwN5W5xK5du3Dnzh2MHz9eb7mI3qL1Z1X35Ur1Z1BQkLyPkP48+uijACqOgNq2bZvsBlT0Z2FhoXxEjkR2drZd+9OU97Zt21CvXj0AMPK2BlEzz8nJQXp6Oho2bIidO3eiVq1awniby7ysrAy3b982eo4TJ04AgHyUnYiZP//880b9uWLFCgBAu3btsG3bNjRp0kQ476KiIvnodFPYsz9t3T7HjBmDgoICvf6XzvYODw+Hk5OTkGNFl40bN0Kr1SrWn7Zk3qRJEzg5OeHq1at6zyEdWRwcHKy4uzWZS0hf5Li4uGDq1KlCvGdZvXo12rZtK5+pAIjTn+aeS3r/auhtDUq7A6YzF6U/zT2XqcxF609Lz2WYuUj9aYu3SP1p7rnMbZ8i9ael5zK1fUoo3Z/mnstU5qL1p7nnSklJsZi5hFarxcsvvwyNRoOpU6dW2eUfccYCACxcuBCHDx9Gt27d8PTTT6NVq1bIzs7GqVOncODAAflmG+ZITEzEt99+C6DixjTSqZtAxc5yyJAhAIAlS5Zg2bJliIyMhEajwV9//QUA8o0lhw8fDg8PDzg7OyMiIgKnT59G9+7dMWnSJPkUyby8PLz++uuKeq9bt07PXfKWnI4ePYq8vDwsX74c27dvl2/0LL2Jtaf7ggULcOzYMQwcOBANGjSQb4by3Xff4bnnnkOTJk3k52zRogUSExMxaNAgzJ49Wz711MPDQ77BiVLe2dnZ+PrrrwEAM2bM0PPOyclBYmIicnJy5JvyfPrppwDuvdkQNfP9+/ejrKwMEyZMQEJCAhISEuTXkm7QKqL3jh074OzsjEWLFsHPzw+XLl0CUHEq88KFCxXN29xYadGiBVq0aIHt27fjypUrePzxx/Ver0WLFnLBiJj5li1b4O7ujo8++gju7u7yWKlTpw6eeeYZITMHgGeeeQZvvfUWsrKy8NJLL6FBgwZYu3YtAGDAgAHyeiJmLhEfHw83NzeMHDkS0dHReo+J5i1af9oyVkTqT41GY7SPOHDggJyx4WNt27bF5cuX0adPH8TExMhvuoOCgvDUU08p6g0Ac+fOBQCjx5KTk+X+lA4qkJ7zjz/+kNcTLfO8vDzs27cPWq0WEydOlG9sJ73W8ePHERkZKVzm+fn5CA0NlS9PsmLFCpw5cwZxcXEAIJ+pA4iXeceOHdGgQQO9/pQu6RAUFCQvE807NTUVX3/9Ndzd3bF06VIAwN69ewFUXEJj2LBhinoD5rfPV155BZ9//jnS09Px5ptvwsfHB5999hkAoG/fvvJ6omWuS3x8PEJCQtC7d2+jx0TLPDAwEFOmTMGqVavg7u6OTz/9FHl5eVi2bBkAoGfPnoq7W8r8xIkTyMrKwvLly1FaWor169cDAAYPHizf4NZe3f/yyy/j77//Rt++fRESEoKff/4ZAHD37l188sknes8pSn+a8k5KSsLGjRsBwMhbpP60JXOR+tOWzEXrT1syF6k/bfEWqT9NeVvaPkXqT1sy10Xp/jTlbS5z0frTnPuKFStMZh4TE4OioiK0b99e7s8TJ05gzZo1RjeIvy+qfJcGO1GVmzdLpKWl0fTp0yk0NJTUajUFBwdT37596fPPP6/09ePi4szefCMqKkrPxdx6QMUNd3XXDQgIoK5du5Kvry/VqlWLANATTzwhtPfOnTspICCAVCoVaTQa6t69O23evFmxzPft20eDBw+mkJAQUqvVpFarCQDFxcWRVqvVe86oqCiqX78+jRo1iry9vcnT05MA0HPPPae4t5eXFwUHBxMAI2/p5kem/hjebEW0zC2Nq4ceekhY73bt2pGrqyv5+fmRi4sLhYSEEACaOnWq4nlbGitExvtE6TlF3z6bNm0q//vUajU1adKE8N+bPintXVnmY8aMIQ8PD/L39yc3Nzfq1q2bQ2QeFRVFDRo0IHd3dxoxYgQRKdeftnqL0p+2jBXR+tOQym5UGhISQgMGDCCNRkO+vr4EgGbNmqW4N5H5G5UePnzY7HMavncUKXNLvW/4nCJlXlxcTDExMeTn50cqlYrUajWFhYVRdHS0w4xz3XFhePNJEb1v375NjRo1IhcXF9JoNOTm5katW7cmAPT6668r7k1k+UbfI0aMII1GQ97e3lSrVi16+OGHHWasSO8NZ86cSUTK9acpzGVeWlpKXbt2JbVaTZ6enuTp6Ul9+vQRxt1S5g888ACp1Wry8PAgLy8v6tu3r2Le69evp169elFgYCC5uLiQu7s7AaDffvvN6DlF6k9D74CAAGrUqJFD9Ke1mYvWn9ZmLmJ/2jrORelPa71F609btk8isfrzfvaJIvSnLZmL1p+m3IcPH24y87i4OGrXrp1efx46dKhSF2tREZm5SBTDMAzDMAzDMAzDMAzDMAzDMIwB/4h7LDAMwzAMwzAMwzAMwzAMwzAMUz3wxALDMAzDMAzDMAzDMAzDMAzDMFbDEwsMwzAMwzAMwzAMwzAMwzAMw1gNTywwDMMwDMMwDMMwDMMwDMMwDGM1PLHAMAzDMAzDMAzDMAzDMAzDMIzV8MQCwzAMwzAMwzAMwzAMwzAMwzBWwxMLDMMwDMMwDMMwDMMwDMMwDMNYjYvSAqKhUqnMPkZEdjSxDUf1BhzX3VG9Acd1Z2/746jujuoNOK47e9sfR3V3VG/Acd3/V7wjAfyku8CB3HUROXOoVLgC4Hk/P3xy+zYaA7gKoBeA6yJ7w3EzZ2/746jujuoNOK67o3oDjuvO3vanh0qFtQAaA/gbQG8AN/77mMjujpy5I7sbwhMLDMMwDMMwDMMITX0Aa5WW+AfwNyq+WNh5+zYAoBRANoBcBZ0YhmEYhqk5pIM2DCcVGMYa+FJIDMMwDMMwDMMIS30AP+DekXQ9AKBRIwWN/neZZfCzGoAvAC/7qzAMwzAMY0cmgicVGNvhiQWGYRiGYRiGYYSkHvQnFXoDOA4AP/yglNL/NF8b/FwKYByAFAVcGIZhGIaxH2tRcTAHw9gCTywwDMMwDMMwDCMkeQDSYeL0/NBQhYz+t1Hr/L30vz9vAH/RwDAMwzD/q/TAvUsh/gDufMY2eGKBYRiGYRiGYRghyQUwEMBD4NPz7c0T0P+igWEYhmGY/z2Oo+LgDd3Or6egD+NYqMjRbjfNMAzDMAzDMAzDVD8q1b2/N2oErF8PPPkkEBQEHD+unBfDMAzDMDXL9etA794Vnb9nD+Djo7QR4wDwxALDMAzDMAzDMAzDMAzDMAzDMFbDl0JiGIZhGIZhGIZhGIZhGIZhGMZqeGKBYRiGYRiGYRiGYRiGYRiGYRir4YkFhmEYhmEYhmEYhmEYhmEYhmGshicWGIZhGIZhGIZhGIZhGIZhGIaxGp5YYBiGYRiGYRiGYRiGYRiGYRjGanhigWEYhmEYhmEYhmEYhmEYhmEYq+GJBYZhGIZhGIZhGIZhGIZhGIZhrIYnFhiGYRiGYRiGYRiGYRiGYRiGsRqeWGAYhmEYhmEYhmEYhmEYhmEYxmp4YoFhGIZhGIZhGIZhGIZhGIZhGKvhiQWGYRiGYRiGYRiGYRiGYRiGYayGJxYYhmEYhmEYhmEYhmEYhmEYhrGa/4mJhcmTJ6Nhw4Z6y1QqFd58801FfKzFUb0Bx3V3VG/Acd3Z2/44qrujegOO687e9sdR3R3VG3Bcd0f1BhzXnb3tj6O6s7f9cVR3R/UGHNfdUb0Bx3Vnb/vjqO6O6g04tntNIuzEgkqlsurPDz/8YBefffv2ITo6GhEREXB2djYaTPfrXVpaioEDB8LT0xP+/v4AgLt379rd2xb35cuX4+eff8atW7egVquhUqmqzfd+3K31PnToEC5fvoz09HSEhobCw8MDERERAICysjK7e9viPnv2bOzZswfXr1+Hm5sbwsPD8dRTT1Wbs63u97t9lpaWolWrVgCAn376SWjvhIQEJCcn6y0HgE8//dTu3ra6ExHy8vLQvn171KpVC7Vr1wYApKam2t3dFu81a9aYzPytt95C//797eptq3tSUhJu3boFX19f1K5dGw899FC1+N6Pu63bZ15eHlq2bAk3NzfUq1cPAFBSUiK8tyj9+eabb3J/2tnblsy5P6vH25bMBw4caHZ/Xp3UZObLly+XOxQA1qxZgz/++ENYb5H605axwv2pjLco/WmLO/dn9Xjb4s79WT3etrhzf9rfW6T+tNWd+7Pq3ra65+TkIC0tTe7PiRMnVpvz/bhfvnwZo0aNgp+fHzQaDR588EEcPnzYaL0TJ05g2rRp6NSpU410qEu1Pls1snbtWr2fv/rqK+zfv99oecuWLbFy5Upotdoa9Vm/fj02bdqEjh07IiQkxOx6a9euRXJyMhYsWAA/Pz94eHjg0qVLGDZsGLKzs/F///d/sve8efOwc+dOXL58Ge+++y7y8/Px2muvYe3atViwYAFcXV3t5g0A8+fPl7179uyJM2fO4Pz58+jZs6fsDQC///47/v77b7Rp0wZ3797FxYsXq+xZFXdrM2/YsCGOHTuGrl27YujQoQgKCsLx48dx7tw5rFu3Du+88061bGA1kfmBAwcwYMAAtG7dGoGBgbh69SpWrlwJoGKnXF3UxDjX3T5jY2Nx7dq1avOtSe8ePXrg+vXr+OKLL+TfnzhxYrW9wbDFG7B+rLRs2RJEhJycHDz++OOYMWMG7t69ixdeeKFaPzTWROZxcXEgIqjVavn3pbIeMGCAXb0B6zM/duwYfvzxRwwcOBDDhg1DUVERvvzySwDAn3/+WS3etrjbknlAQACys7Px8MMPIyYmBufPn0dsbCw2bdqEd999167eCxYswPXr1+WfExIScPbsWfj7+6OoqAj/+c9/4OLiIlx/jhgxAmlpaXrLJHeNRiN7A+L1p7WZi9aftmQuWn/aMs5F6k9bMv/uu+/g6uqKzz77zOT+3N7utmY+ZcoUPP/885g0aRJmzJiBp59+Gj4+PkhPTxfWW6T+tGWsiNaftmQuUn+uXLkSc+fORXFxMfr164eLFy/i/PnzcHZ2Rr169fDOO+/AyclJuP7Mz89H7dq1Ze/atWtj3759uH79Oho0aCB7A+L1p7WZi9aftmQuWn/aMs5F6k9bMhetP23NXJT+tMVbpP60ZayI1p+2ZC5Sf16/fh2enp5wcnLCI488Ajc3N2zfvl3uxhYtWsjr+vj44OjRowgJCUFMTAzy8/PxwQcfAADKy8urxdtW98jISDg7O+Oll16Ch4cH4uLiMGDAABw8eBC9evWS1921axdWrVqFtm3bolGjRtXfoeQgTJ8+nWzRBUDz5s2rttdPSUmhkpISIiIaNGgQhYWFmVyvvLycIiIiqFu3blRQUGDR+9lnn6VatWpRcnKynjcAWrFihaLeROYzT01NNbmO6JkXFxfTsWPHjJZLme/fv19RbyLbxvnJkycJAPXt27davIlqZpxLpKWlkY+PD7399tsEgPr37y+0d1RUFHl4eOgtE2WME5kfK5s2bSIA9M033wjpfj/7cgB0/fr16tCukcybNm1KXbp0Ia1WKy/LyckhANSsWbNq8a6KuznvmzdvkouLC02cOFFvuZT5t99+a1dvQyRvlUpFTz/9tN5jIvWnKaKiogiAkbdo/WmIucxF609TmMvcFEr2pyGWxrmECP1pCnOZm+pPIvHHOZHpDnUEb1Mo1Z+mMDdWROtPQ8xlLlp/xsfHEwDauXOnnve///1vAkCnTp2S1xWpPw29dd0NvUXrT2szF60/bcncFEr2py3jXEKE/rQlc9H605bMRerP+xkruijVn7aMFdH609rMRevPadOmkYuLC124cEFe9swzzxAA6tixo966pvpz//79BIAGDx5cLd5Vdb979y6FhoYauZvr0OpC2Esh2YKp61yZIiUlBVOmTEGdOnXg5uaG1q1bY/Xq1Va9RkhIiN4spjn27duHs2fPYt68eahVq5bFUxzj4uKgUqnQoEEDveX+/v7YvHmzot4FBQUgIpPr1qlTB88++6zDZe7q6orPP//crLfuzK5omQPG41z6e1FRkd56ImWu6z137lw0b94cEyZMMLmeaN4JCQkoKChAeXk5cnNzza4n2lj56KOPEBAQgBdffBFardbiWQqiZW44xouLiwEAYWFhqF+/vqLeljLPzc3FrVu3EB4eLi/z9vYGAKPXEinz48ePo6ysDHv37jX5+MaNG+3qbQ4iwvjx4/WWidSfppCOAjH0Fq0/zWGYuWj9aQpzmQNi9ac5TI1zkfrTFJYyLy4uRsOGDS32JyBe5tOnT4erqyuGDx9usUNF8xapP01hbqyI1p/mMMxctP6UtrM6deroLa9bty4AyJckAcTqT3PeErreovWntZmL1p+2ZA6I1Z+2jHOR+tPWzEXqT1syF6k/72esSCjZn7aMFdH609rMRevPo0ePokOHDmjevLm8TDqr8tSpU7h06ZK8fOvWrQgKCtI7E6Bfv34AgHPnzuk9r1LuGo0GQ4cONXKvU6eO0b6mOhH2UkjVTVpaGrp37w6VSoUZM2YgMDAQu3fvRnR0NHJzc/HCCy9Uy+scOHAAAODm5obOnTvjt99+AwCMHTsWy5Ytk69jmZKSgqKiIvj5+Rk9R7169XD69GnFvaXTrLKzs2VvWxAt88oICAhQ3LuyzLVaLdLT03Ht2jW8/fbbAKBXJqJmXlJSgjVr1iAhIcHk6b6iehMRvL29UVBQIG+rutf+E22s5Obm4sSJE2jevDlu3boFHx8f5Ofn640REdwB67bPXbt2AQDatm0rhLe57bN3797YvHkz/Pz8kJSUhKKiIsTGxgIAunXrJoQ7YJy59MbZ3Cn40u/Zy9scoaGhem/gROtPU0hfoul624JomVeGvfvTFJVlLkp/msNc5qL0pyksZV5WVoZr167Bx8cHfn5+GDdunFDugHHmubm5yMzMhJeXF1599VXExsYiPz8fgP4HRtG8TaFkf5rC3FgRrT/NYZi5aP3Zq1cvODk5ISYmBh9++KE8bhcsWIDHH39cvpSDaP1p6F2/fn0kJycDgJ63LYiWeWXYuz/vJ3NR+tPWzEXpT1szF6k/rc1ctP6syvapZH/aMlZE609rMxetP4uLi012oq5P06ZNkZKSgvT0dHTq1AmZmZlG6926dUv+u9LuGo1Gz90uVOv5DzVIZZcsMTw9BAanXUVHR1PdunUpMzNTb72xY8eSj4+PfFqINVg6HWXo0KEEgGrXrk3jx4+ngQMHEgBycXGhHj16yKcq/frrrwSAAgICjLx79OhBAKioqEgx7y1btlDnzp1lH91TrIjuZW7pVFTRMtf11gUAubq60u3btxX1tiZz/PcUMen3HCVzV1dXGjduHBERXb161ehUVBG9IyIiyNvbmzZt2kQbNmyQ8w8NDaXS0lJFvc2NlVOnThEAcnNzIycnJ1q2bBnFx8dT165dCQCNHz9efk4RMzfcPkeOHEkAaM6cOYp7W9o+09LSqG7dunrbZ0BAgPDb52+//UYAyNfXV+/3pX+Dp6enXb0NGTduHAGgl19+WW+5aP1pyNmzZ+UMTSFSfxpiLnNdb12U6k9DrMlclP40pLLMRelPQyxlPnfuXIqIiKDAwEC9/gRAb7zxhuLu5jKXOtTJyYnq1Kkjd6jkvnv3biG9icTqT0MsjRXR+tMQc5mL2J+rVq0iX19fvSyjoqLk96xEYvanKW8Aet4SovWnNZnreuuiZH/amrlI/WlL5iL1p7WZi9if1mQuYn/e7/apdH9aO1ZE7E9rMhetP4cMGUK+vr6Um5srL9O9/NQHH3xARPf688EHHzS5P5f6U2l3IqLIyEg9d0P4Ukj3CRFh69atGDJkCIgImZmZ8p9HHnkEOTk5OHXqVLW8ljQz16VLF6xbtw6NGzcGALzzzjv46aefcPDgQQBAYWEhANMzddKpNwUFBYp5jxw5Up7p1PW2FhEzN4V0c5h+/frB19dXUW9rMq9Tpw527dqFDz/80OgUZlEzv3z5MkpLS/H++++bfC5RvTt16gQ/Pz+MHj0aY8eOlW+GdP36dWzZskXIsSKtV1xcjKCgIDz77LN48skn5cePHDkCQNzMdcnNzcX3338PAHB3d1fc29L2qdFo4O3tDQ8PD3z99ddYvXq1fNpndna24u7mMu/YsSMCAgKQk5ODuLg4JCUlYffu3QAAJycnFBYW2tXbkL/++guA8aUzROtPQ+Lj46v0+yJmbgol+9MQazIXpT8NsZS5SP1piKXM33vvPXTq1AkajUbuzwULFgAAzp8/r7i7ucylfadWq8WOHTvkDgUqTuGfP3++kN6GKN2fhlgaK6L1pyHmMhexP+vVq4euXbtiyZIlePTRRwFUZD937lx5HRH7U9d727ZtaNeuHQDoeVuLiJmbQun+tDVzkfrT2sxF609rMxexP63JXMT+vJ/tU4T+tHasiNif1mQuWn8+++yzuHPnDsaMGYPTp0/j4sWLOHr0qPy41JvSf52dnc0+lwjuL7zwAk6ePKnnbBeqZXrCDlTljIW0tDSjGT/DP4Y3OrWEpVmjQYMGEQBas2aNnndycjIBoLfeeouIrDti5Nq1a4p567rrektUdsSIiJnrehMRbdy4kVQqlTDeuu6WMpe4fPkyAaBHH31UcXdzmefk5JC7uzv5+PjIv2t4xIiI3kTm9ysAKDo6WsixIu1XPD09Tbo7OTlRaWmpQ2S+evVq2UX07XPgwIFUv359vefKysoiANSqVSvF3S1l/sQTT5Cbm5vs4OzsTAAoJCSEfHx87Oqti1arJS8vL7lfdBGtPw29w8LCyN/f36Q7kVj9aehuLnNdbyLl+9PQ29rMJZTsT0N3c5mL1p+G3rZmXlBQQACoQ4cOirtXtm9xcXHRWw6A2rdvT2q1mlJSUoTzJhKrPw29LY0V0frT0N1S5iL1Z0JCAjk7O9Ovv/5KRPd6/8033ySVSkXnzp0jIvH609Bb113XW0Kk/rQ2c11vIuX7834zl1CyP63NXLT+rGrmSvanrfsWUfrzfrdPpfvTlrEiWn/akrlI/UlEFBsbSx4eHvJz+/j4yH//+OOPicj6MxaUdm/SpAktWrRIz92Qmjhj4R9xjwWtVgsAmDBhAqKiokyuo3sNtaoQEhICwPimJUFBQQCA27dvA7h3E5Py8nKj58jLy4O/v798ww4lvSUkb2sRMXNd9u/fj0mTJmHQoEHYuXOnUN4SlWUuHYWcmJgIQAx3w8w/+OADaLVaeHh4ICkpCQBw48YNABUzqElJSfJ160XytoRGo0F2drYQeUtI3tJ60hEWhkg30hLBvbLM4+Pj4ePjg5ycHHmZCN4SkveVK1ewZ88eREZG4ubNm/Lj0n0Mrl+/Loy7qcw1Gg2Cg4Oxf/9+pKamomnTpqhbty5yc3PRsmVLu3rrcuzYMeTl5Zl8TLT+1OXYsWNITk5G9+7d8fPPP9/Xc4iYuS4i9Kcu95O5kv2pi6XMRetPQ29bM5duGCcdPSVi5tK+U8pVFw8PD5SWlspHZYrkbYjS/amLpbEiYn8aulvKXKT+XLFiBerUqYPOnTvrLR86dCjefPNN/PTTT2jVqpVw/WnOGwCISPa2FhEz10WE/qxq5kr2p7WZi9afVc1cyf60NnPR+vN+tk9A+f60dqyI2J+2ZC5SfwLAjBkz8NRTTyExMRGurq5YvXo1li1bBgBo1qwZgHufP82dBeDu7g43NzfF3du3b48vvvhCz90e/CMmFgIDA+Hl5YXy8nL5rt01RadOnbBy5UqkpKToLZc2+MDAQAAVpwm5ubnJNy/RJSUlBe3btxfCW0LythYR3A0zlyguLsbw4cPRuXNnbN68Wb65iSjeui7WII0hEdwNM7927RpKSkpw8+ZNoxsIJyQkIDw8HCdPnhTO2xIFBQUIDAwUIm8JyTskJATBwcHIzc2Fh4eH0XrOzs7w8vKCp6en4u6WMr916xYOHz6MyZMnY/Xq1fJyETNPS0sDUPFmzxTSmwsR3C1l3rRpU72bO+Xn56Nfv3529dbF0qUzROtPXeLj46FSqdCsWbP7nlgQMXMJUfpTl6pkrkR/6mIpc9H6U5f7yVz6glYaMyJmHhISAnd3d5SWlho9lpeXB3d3d4SHhwvnrYsI/amLpbEiYn/qYm3mIvRnWlqayckCaSyXlZUBEK8/zXlLSN7WIoK7YeYSovRndWWuRH9am7lo/VnVzJXsT2szF60/bd0+ATH609qxImJ/3k/mIvSnhIeHByIjIwEAcXFxACom9R544AEAFf0ZGBho8sbNABAcHAxAmfcsuu4AcODAAT13e/CPuMeCs7MzRo4cia1bt+Ls2bNGj2dkZFTbaw0bNgxubm6Ii4uTN2gAWLVqFQCgf//+8rKwsDAUFhbKM4oS2dnZeOKJJ4TwltD1tgYR3E1lnpOTg/T0dDRs2BA7d+6UjwAQyVtC8i4rKzN5VPeJEycA3DvCTgR3w8yff/559OnTB4GBgdi2bRu2bduGFStWAADatWuHbdu2oUmTJsJ5FxUVmXxjJDFw4EAh8pbQHeNjxoxBQUEBioqK5GVSAYaHh8PJyUkId1Pbp8TGjRuh1WqNrmksgreE5N2kSRM4OTnh6tWreo9LR0ZJbzJEcLeUuYS0vouLC6ZOnWpXb4nS0lJ8/fXX8pEhphCpPw29H3zwQXh5ed3384iauUj9aehtLnMR+1OissxF609Db3OZFxUVmTzK+5133gFQsc8ExMwcqOjJ8vJy7N+/X2/5hQsX8PDDD0OtVgvpLSFCf0pUNlZE7E9Dd2syl1CyP5s1a4a0tDT88MMPess3bNgAAOjQoYO8TKT+NOctoettDSK4m8pcpP60NnMR+9PazEXrT2szF7E/bRnnIvWnLd4SIvSntWNFxP68n8wlRPj8qcutW7cAANHR0fDx8ZGXjxw5Ejdu3NCbQJHuXdi6dWsAyrxn0eWnn37CN998Y+Re0/wjzlgAgIULF+Lw4cPo1q0bnn76abRq1QrZ2dk4deoUDhw4IN/gxByJiYn49ttvAVTcDCgnJwfz588HUFFQQ4YMAVCxEb/22mv497//jYEDB8qz+QsXLsS4cePQpUsX+Tnbtm2Ly5cvo0+fPoiJiZFPDwsKCsJTTz2lqPfjjz+Ow4cPA4CRd3JyMhITE5GTkyPfGER6zj/++EPYzPPy8rBv3z5otVpMnDhRvjGP9FrHjx9HZGSkcJnn5+cjNDRUPj1sxYoVOHPmjDyT2qtXL2Ez79ixIxo0aIArV67g8ccfBwD5lNSgoCB5mWjeqamp+Prrr+Hu7o6lS5cCAPbu3Qug4hTgYcOGKeptaft85ZVX8PnnnyM9PR1vvvkmfHx88NlnnwEA+vbtK68nWua6xMfHIyQkBL179zZ6TLTMAwMDMWXKFKxatQru7u749NNPkZeXJ58+2bNnT8XdLWV+4sQJZGVlYfny5SgtLcX69esBAIMHD5Zv0Gcvb4m9e/ciKysLDz30kPzGzhCR+tPQe/z48Thz5ozJ5xStPw3dzWUuWn8aepvLXMT+NHQ3l7lo/WnobS7z1NRUdOjQAXXq1EFeXh6WLl2KvXv3YteuXQCAFi1ayOuKljkAtGnTBhcvXsTIkSMxc+ZM+UOZVquVb7gqoreECP1p6G1urIjYn4buljIXqT9nzJiBuLg4DBkyBM8995z8ZcaSJUvQv39/dOvWTX5OkfrT0DssLAz79u0DACNv0frT2sxF609rMxexP63NXLT+tDZzEfvTln2LSP1pi7eECP1p7VgRsT9tyVyk/kxOTsbo0aMxdOhQBAcH49y5c9ixYwcAyONW4tVXX0VcXBxSU1MRGxuL/Px8LF68GADQvn17u2duyv2zzz5D27ZtjdyTk5Oxdu1aADDq0LCwMEycONGiU6VU6x0bapCq3LxZIi0tjaZPn06hoaGkVqspODiY+vbtS59//nmlrx8XF2f25htRUVF662q1WoqNjaVmzZqRk5MTAaDXX3+dSkpKjLxDQkJowIABpNFoyNfXlwDQrFmzFPdWq9Xk6elJAIy8Dx8+bPY5Df8/iJS5dNMma55TpMyLi4spJiaG/Pz8SKVSkVqtprCwMIqOjnaYca47LgxvniWi9+3bt6lRo0bk4uJCGo2G3NzcqHXr1vK6Sntb2j6JiEaMGEEajYa8vb2pVq1a9PDDDzvMWAkJCSEANHPmTCISZ19uKfPS0lLq2rWrvI6npyf16dNHGHdLmT/wwAOkVqvJw8ODvLy8qG/fvop6ExGNHTuW1Gq1vI8zhWj9qeudlZVl9j2LiP2p624ucxH7U9fbXOai9qeue2XjXKT+1PU2l/nt27dpwoQJ5OXlRSqVSu7Pd99912Eyr1evHg0fPlzuUAD0r3/9S3hvkfpT19vSPlHE/tR1t5S5aP154cIFGjVqFIWGhsq9P3v2bLp7967eeqL1p663Wq2Wb5ht6C1if1qTuYj9aU3movanLeNcpP60JnNR+9OWzEXqT1v3iaL0p7X7RBH709rMRerP7OxsGjZsGAUHB5OrqyuFh4dTx44dzXb/sGHDyN3dXe7P8ePHC+U+Z84cys3NNXpOSx360EMPVepUGSoiMxfmYhiGYRiGYRiGYRiGYRiGYRiGMeAfcY8FhmEYhmEYhmEYhmEYhmEYhmGqB55YYBiGYRiGYRiGYRiGYRiGYRjGanhigWEYhmEYhmEYhmEYhmEYhmEYq+GJBYZhGIZhGIZhGIZhGIZhGIZhrIYnFhiGYRiGYRiGYRiGYRiGYRiGsRqeWGAYhmEYhmEYhmEYhmEYhmEYxmpclBYQDZVKZfYxIrKjiW04qjfguO6O6g04rjt72x9HdXdUb8Bx3SXv+gB+ANAYwN8A3m7SBGsuXVJOrBIcNW/Acd0d1RtwXHf2tj+O6u6o3kCFu24HSfwNoLHA7o6auaN6A47r7qjegOO6O6o34Lju7G1/TLnXA5AHIEdg9/+1zCVEdzeEz1hgGIZhGKbauAGgN/77RQ6ANZcvK+rDMAzD/HO4AWCiwTLDnxmGYRiGuUd9Ez//CGCPAi6M48ETCwzDMAzDVCumvthhGIZhmJqmPoC1BssMf2YYhmEY5h4/4N7kgu6Zf0EK+TCOBU8sMAzDMAxTrZj6YodhGIZhahLDS/H1wL2z5xiGYRiGMU1jVPRnJPR7tLdiRowjwRMLDMMwDMNUG6a+2GEYhmGYmuYH6H8Zchz3Ls3HMAzDMIxppEn4n6DfozcUdGIcB55YYBiGYRimWqgH01/sMAzDMExNkw7jL0Ok+/4wDMMwDGMaU/cm4kkFxlpU5Gi3m2YYhmEYRkxycoCBA4H0dOCHH4DQUKWNGIZhmH8KOTlAXh5Q3/A2lAzDMAzDmKVxY+DKlXs/N2rEn+UYq+GJBYZhGIZhGIZhGIZhGIZhGIZhrIYvhcQwDMMwDMMwDMMwDMMwDMMwjNXwxALDMAzDMAzDMAzDMAzDMAzDMFbDEwsMwzAMwzAMwzAMwzAMwzAMw1gNTywwDMMwDMMwDMMwDMMwDMMwDGM1PLHAMAzDMAzDMAzDMAzDMAzDMIzV8MQCwzAMwzAMwzAMwzAMwzAMwzBWwxMLDMMwDMMwDMMwDMMwDMMwDMNYDU8sMAzDMAzDMAzDMAzDMAzDMAxjNTyxwDAMwzAMwzAMwzAMwzAMwzCM1fDEAsMwDMMwDMMwDMMwDMMwDMMwVsMTCwzDMAzDMAzDMAzDMAzDMAzDWA1PLDAMwzAMwzAMwzAMwzAMwzAMYzX/ExMLkydPRsOGDfWWqVQqvPnmm4r4WIujegOO6+6o3oDjurO3/XFUd0f1BhzXnb3tj6O6O6o34LjujuoNOK47e9sfR3Vnb/vjqO6O6g04rrujegOO687e9sdR3dn7fw9hJxZUKpVVf3744Qe7+Ozbtw/R0dGIiIiAs7Oz0YCy1fvQoUO4fPky0tPTERoaCg8PD0RERAAAysrK7O5ti/vs2bOxZ88eXL9+HW5ubggPD8dTTz1Vbc62ut/vWCktLUWrVq0AAD/99JPdvW1xHzhwINasWYPk5GS95dVNTWa+fPlytG/fHrVq1QIArFmzBn/88Yew3ubyfuutt9C/f3+7etvqnpSUhFu3bsHX1xe1a9fGQw89VC2+9+Nu61jJy8tDy5Yt4ebmhnr16gEASkpKqsW5oKAA//nPfzBgwADUrVsXXl5e6NChA5YvX47y8vIquefk5CAtLQ2enp7w9/fHxIkTq8X5ftxt8c7MzER2djY6deoEtVpd7fuVmvC2R3/W1FixR3/W1FjRpSb6s6Yyt0d/1nTmNdWfNZW5SqUym/lXX31VZW9b3W3NvKCgAN27d5c7FAAuXrwovLej9mdBQQEyMjLg6+sLb29vDBs2rFqc78fd1t7Pzs5Gjx494O7u7jD7leTkZGRkZKBRo0bQaDRo3rw5AKCoqMju3ra4v/POO9i/fz9u3LgBNzc31K9fH6NGjaoW5/txv9/+BCB/jti1a5fdvW1xnzx5ssP356ZNmxAZGQkPDw8AwBdffIFDhw7Z1dsW9+DgYLOZL126tMretrrbmnlRURH69OmDgIAA+Pr6AkC1fd6vSe+7d++iY8eOcHd3R2BgoPx69va+cOEC96fA3iL154ULF/Dyyy+jffv28PLyQt26dTFo0CCcPHnS6Hm3bduGRx55BCEhIXr9efbs2WrxBgCXanumambt2rV6P3/11VfYv3+/0fKWLVti5cqV0Gq1Neqzfv16bNq0CR07dkRISIjZ9ZYsWYLXX38dTk5OeOSRR5CYmIi//voLTk5OeOWVV9CiRQsAQMOGDXHs2DF07doVQ4cORVBQEI4fP45z585h3bp1eOedd6plA7PW+/r16/D09JS93dzcsH37duTn5+O1116TvQHgwIEDGDBgAFq3bo3AwEBcvXoVK1euBFDxoaa6qO7MDcdKbGwsrl27Vm2+tnrbkvl3330HV1dXfPbZZ1Cr1fLy6v7ysqYynzJlCp5//nlMmjQJM2bMwNNPPw0fHx+kp6cL6x0XFwciMpn3gAED7Opty1g5duwYfvzxRwwcOBDDhg1DUVERvvzySwDAn3/+WS3etrjbknlAQACys7Px8MMPIyYmBufPn0dsbCw2bdqEd999t8rOV65cwXPPPYe+ffti5syZ8Pb2xt69ezFt2jT8/PPPWLNmjd76gwcPxs6dO9G7d280atQI3377LTIzMzFt2jRERkbK6/n4+ODo0aMICQlBTEwM8vPz8cEHHwCAyQ8XNe2+du1abNq0SXZPS0uT/9/rurds2RIdOnTA3r17oVKp0KhRo2r78qwmve3RnzU1VuzRnzU1Vmq6P2sqc3v0Z01mXpP9WVOZ5+TkwMPDQ69DT548iU8++QSNGzeusret7rZk3r59e6xZswZdu3bFwoULUVRUhBdffBEbNmzAqFGjMGLECCG9RetPoKIbGzRogDNnzqBRo0a4cuWK0ee4Bg0a4PTp0/Dw8MDs2bOhVqvx8ccfA6i+L3VszXzixIl67tJyXVq2bIlBgwZhx44d8oTO77//Xi2+Ne2dmJiI8PBwjBgxQl734sWLWLVqFebNmydPYNrDW8KasZKYmIgHHngA7dq1Q3BwMFJTU7F69WoAQGpqapWc78fdlsx1+/Obb77B8ePHq8X3frwlrMlcGtNLly6Fn5+fvFzJ/rQl87feegvjxo3DqFGjMHnyZEydOhV16tRBSkqKXb0lrMlcOkBGtz+Tk5Px+uuvK9af1mY+dOhQrFmzBo0bN8abb74JlUqFGTNmYPv27fj444/x4osvCunduXNnrFmzBu3atcNHH32EGzdu4L333sOaNWvw9ttvw93d3W7eq1atgkajQZcuXdCoUSMUFhZix44dKCwsxJw5c+QDqQDx+vPRRx/Fjz/+KLsnJCTg0qVLUKlUePnll2V30frTFm+R+nPVqlX44osvMHLkSEybNg05OTlYsWIFunfvjj179qBfv37yumfOnIGfnx9iYmIQEBAg92fXrl1x/PhxtGvXrkreAAByEKZPn0626AKgefPmVdvrp6SkUElJCRERDRo0iMLCwkyuN23aNHJxcaELFy4Q0T3v0NBQ6tixo7xecXExHTt2zKQ3ANq/f7+i3kREzzzzDAHQ8zbHyZMnCQD17du3WryJqj9zXdLS0sjHx4fefvttAkD9+/dX3JvIfOZRUVHk4eFh9Byij3Miok2bNhEA+uabbxzK2xTS9nn9+nVFvYnMj5WmTZtSly5dSKvVystycnIIADVr1qxavKvibi7zmzdvkouLC02cOFHv96XMv/322yo7Z2Rk0NmzZ42WP/XUUwSALl26JC+7ceMGqdVqmj59ut6/BQDVr1+fysrK5OXPPvss1apVi5KTk+Vl+/fvJwA0ePDgKntX1V3KvGfPnkbuqampVFBQoLdedW6fNeFtj/6sqbFiiuruz5oaKxI11Z81lbk9+rOmMq/p/rTnOI+OjiYA9OKLLyrubilzUx0KgNRqNQ0dOlRIb9H6k4jo6tWr8u8BoC5dupj8HPf+++8TADpx4oS87M8//yQA9OCDD1bZuzrczX3+zMrKotzcXCIiWrx4saL9aYv34cOHjZZJ669cuVJxb3NjxRSpqakEgDp16lRlb8mhJjKXKCwspIYNG8r92aVLFyG8zWU+b948AkAZGRl6yx1hnB8/fpxUKhV99NFHQnrbMs7feecdAkBTpkypsrfkUBOZ9+/fn0JCQqioqEheBoD8/Pyobdu2QnoXFxeTr68v9erVy6j3AdDSpUvt6n3y5EnKy8vTW096//TAAw/oLRetPw3dpfcsgYGBRu4i9act3iL1p6mxkpmZadLbFKmpqeTi4kLPPPNMlb2JiIS9FJItmLrWlSlSUlIwZcoU1KlTB25ubmjdurV8pENlhISE6B3pZo6jR4+iQ4cO8mkxEkOHDsWpU6dw6dIlAICrqys+//xzs966RxYr5e3iUnFCi663hGHm0t8NTwMSKXNd77lz56J58+aYMGGCyecUMfPi4mI0bNgQubm5Fp9XtMynT58OV1dXDB8+HFqtFnfv3nUIb8MxXlxcDAAICwtD/fr1Ffc2N1Zyc3Nx69YthIeHy8u8vb0BwOi1RMr8+PHjKCsrw969e00+z8aNG6vsHRAQgNatWxstHz58OAD9/e6OHTtQWlqKadOmycuko+Bv3Lihd7TZ1q1bERQUhF69esnLpKMEzp07p/daSrkDwLPPPmvkPmfOHLRs2bLS1xfJ2x79WVNjBaj5/qypsVLT/VmTmdd0f9ZU5jXdn/Ya58XFxdi6dSuAe32ktDtgOvPr16/j7NmzRmc9ubq66h2JJpK3aP0JwKrPZQCwZcsW1K5dG0888YS8TDqTUYn+tMV95syZaNOmTaXrieb95ZdfCtOftngDxv0ZFBQEQJn+tMVd8l60aBG0Wi1mz55tcj3RvCU6duyI3NxcEJHZdURzHzduHJycnBATEwMiQn5+vkN4A8bjfP369QCA0NBQod1Pnz6NjIwMuLm56S3XaDR2709rvc+ePYs7d+6Y7H21Wm33/uzUqRM8PT311pPOmDD894nWn6bcAaBnz55G7iL1py3eIvWnKe/atWub9DZFUFAQNBoN7ty5U+m61iDspZCqm7S0NHTv3l0+JSswMBC7d+9GdHQ0cnNz8cILL1TL6xQXF+udKiih0WgAAL/99huaNm1a6fMEBAQI4S1hylur1SI9PR3Xrl3D22+/DQB6X2Yq7W4u85KSEqxZswYJCQkmL5ehtLeEoXdZWRmuXbsGHx8f+Pn5Ydy4ccK5G2aem5uLzMxMeHl54dVXX0VsbKz8xk638ETzNoV0HdS2bdsK4y2h6927d29s3rwZfn5+SEpKQlFREWJjYwEA3bp1E8bdMHNp4sbcJWx+++23GvOWTqGX9rsA5FNLzX3pfvr0aTz44INISUlBeno6OnXqhMzMTKP1bt26Jf9dafeuXbvquVuLo3nXZH9WZazookR/VkfmSvRndWSuVH9WJXMl+7O6xrnErl27TH5wUdrd1DgPDg5GUlISYmNjMWTIEPkLy+LiYsTExAjpLVp/WotWq0ViYiIaNmxo8vrEt2/fRl5eHry8vIRztxZH87Z3f94PWq0WGRkZSE1NxZIlSwAo05+2Ul5ejoULF2L16tUmL5chqjdQMXns4+MDDw8PPP744w7hfuvWLbi6umLp0qWYP38+srKyAAAnTpwQ2tuQ06dPm/ySUET34OBgZGZm4o033kBUVJTcSTdv3pTvDyGat6X+VKvVOH36tLzPUdpbdz1H6s/U1NT7+n/jaN6i9Kcl7zt37qC0tFTuz9zcXPTt29dmH5NUy3kPdsDSpZCioqKMLsMBg1NpoqOjqW7dupSZmam33tixY8nHx0e+FIQ1WLrsx5AhQ8jX11c+tUfyjoyMJAD0wQcfVOrt6upKt2/fVtRb193QW3KXHgNAtWvXdpjMXV1dady4cURUcYocDC7lIGLmc+fOpYiICAoMDKQNGzbo5f/GG28o7m4u81OnThEAcnJyojp16tCyZcsoPj5edt+9e7eQ3kTG2+fIkSMJAM2ZM0deJuJYSUtLo7p16+ptnwEBAcJvn7/99hsBIF9fX73fl/4Nnp6e1e5NVHEKbKtWrSg8PJxKS0v1/k2NGjXSW1c387lz5xIR0a+//iqfcmpqfw5APiVYKXfJ++7du3ruRPrj3NylkET3lqjJ/rTFW9fd0Ftyt2d/2uJeWeb27E9bvHXdDb2V6E9b3M1lrkR/2uKt625unEvb6MiRI8nNzc0hxvmYMWPI3d1dbxuFwSUoRPMWrT91sXTZD+mx9u3bm+1P6TKKSrpb8/nT3KUcRPeWAEAqlYouXryouLelS8RERUWRi4uL3tgGQP/+97/ldUTNXKPRUI8ePeRl0r9VBG9zmS9ZsoRatGhBAQEBtGXLFoqJiZHz191vipZ5dna23J+enp60ePFi+dKCAOizzz5T3LuycS5to7NmzXKYfcv48eNJo9GQSqXS688xY8YI6y09JvWkhK5/ZmamIt4Sw4cPN3rPKnp/Et17z6JSqfTcicTtT1u8JUToT4kjR46Y9JZo3ry5Xn++/vrrVF5ebpOPOf4nLoVUGUSErVu3YsiQISAiZGZmyn8eeeQR5OTk4NSpU9XyWs8++yzu3LmDMWPG4PTp0/IRWtLduQsLC83+rnRztX79+sHX11dR74sXL+Lo0aPy46a869Spg127duHDDz9EgwYN9B4TNfPLly+jtLQU77//vsnnEjXz9957D506dYJGo8HYsWPx5ZdfYsGCBQCA8+fPK+5uLnPp6EqtVosdO3bg2WefxZNPPgkAqFWrFubPny+ktyG5ubn4/vvvAdw7HVHUsaLRaODt7Q0PDw98/fXXWL16NerWrQsAyM7OVtzdXOYdO3ZEQEAAcnJyEBcXh6SkJOzevRsA4OTkhMLCwhrxnjFjBs6fP49PP/1UvryU5GV4Kq8ukrf0X2dnZ4vriuAujV1LPWSIo3jboz+rOlZ0sXd/VkfmSvRndWSuVH9WNXOl+rM6xzlwrz8fe+wxveUiuJsa587OzlCr1YiKipI7FAA2bdqEy5cvC+ktWn9ai4j9WZ04ird0mZXIyEg0bdpUeO+AgADs2bMHy5Ytk8/mkW6MLKp7amoqCgoK5DMsDBHVOyYmBt26dYOHhwdGjhyJJUuWyDcP/fXXX4V11+3PVatWYfbs2Rg9ejSAivFj7/68X7RaLTZu3IgOHTroLRfV3cnJCWq1GqNGjcKGDRuwbt06ABU3LP/555+F9A4ICEDDhg2Rn5+PDz/8EFeuXJE/Yzs5VXxVWlBQoJh3eno69u3bBwB4+eWX5eWO0J+SY3h4uJ67NTiKt0j9mZ6ejieffNKid1xcnF5/FhYWory83CYfs1TD5IRdqMoZC2lpaUZHHhn+0b0xXmVYOjqXiCg2NpY8PDz0nn/RokUEgD7++GOT3hs3bpRnd0Xx9vHxkf+u623oTkR0+fJlAkCPPvqoEO6mMs/JySF3d3fy8fGRf8/wiEulvW3JvKCggABQhw4dhHA3lbl0NLeLi4ve7+K/M+xqtZpSUlKE8ybSz3v16tVGM+lK521urAwcOJDq16+v91xZWVkEgFq1aiWEu7nMn3jiCfmoVgDk7OxMACgkJIR8fHyq3VtyeOedd0z+m6rzjAUl3atyxoIjeNujP6tjrJhyJ6r5/qyOzJXoz5rMvKb7szoyV6I/ayJzqT+3bNkizDZqad8SEhJCtWrV0vt9AOTu7k6jR48W1luk/tSlOs5YUNrd0FuisiMuHcH7yJEj8hk60hGOSntbeyQ30b0j0yMjI4VwN+VdWlpKvr6+5OHhobdc+reK4G1L5pJ7eHi4EO6mvHUfk25yL3n37t2bAMhneomc+aFDhwioOLvbEfYtzZo1I7VarXcENADy9/enrl27Cus9btw4qlWrlpFLixYtCABdvHhREe/8/Hzq0qULubq6GrmL3p/5+fkUFBREAOjMmTNGj4van7Z4i9Sf0ljx8fEx6W2K7OxsqlOnDs2aNctqH0v8I+6xIB3FMGHCBERFRZlcR/e66VVlxowZeOqpp5CYmIiPP/4YX3/9NXx8fAAAzZo1M1p///79mDRpEgYNGoSdO3cK4e3q6orVq1dj2bJlZr11ady4MQAgMTERgJiZf/DBB9BqtfDw8EBSUhKAimtGAhUzk0lJSfLMtCNkLl2fU5pVFTHzkJAQAPdm/HXx8PBAaWmpfFSJSN6GxMfHw8fHBzk5OfIyEbfPK1euYM+ePYiMjMTNmzfl3/X39wdQcVNKpd0tZa7RaBAcHIz9+/cjNTUVTZs2Rd26dZGbm4uWLVtWq/eXX36JOXPmYOrUqXj99deNHq9bty4OHz4MIjJ53U1pbEtng5g7Wtfd3R1ubm5CuEv3e5DcrUF0b3v0Z3WNFXPUZH9WV+b27s+azrwm+7O6Mrd3f9ZU5lJ/Dh48WG+5iJlfuXIFN2/eRO3atY2eo0GDBjh27JiQ3oBY/Wkt/v7+cHNzs3g2WkhIiHzTcpHcrUHEzHX5448/MHToUERERODkyZPyvkZ0b12ke3gp0Z/W8tVXXyEnJwd16tSR+1OiuLgYSUlJQnpXhhL9aS3+/v7yeDY8otvDwwNAxTXoAbG8DYmPj4eTkxPGjRund8NvETMvKSnBpUuX4O3tbfS+pUmTJjh58qR8LwCRvAHA1dUVQUFBOHLkCJKSkhAWFiafxRAYGAgvLy+7e5eUlGDEiBFITEzEY489hu3bt+s9LnJ/Su6Z/733YEREhFXPr4sSY9wWb5H6U3es7N271+q8/fz88PDDDyM+Ph4ffPCBVb9jiX/ExIK0QygvL0e/fv3s8poeHh6IjIxEfHw8AODAgQOoVasWHnjgAb31iouLMXz4cHTu3BmbN2+Wb2iqtDdQcaoMAJPe5pBugCNi5teuXUNJSQlu3rypd5MvAEhISEB4eDhOnjzpMJnn5eUBuHcTXBEzDwkJgbu7O0pLS036u7u7Izw8XDhvXW7duoXDhw9j8uTJ8iURADG3z7S0NAAAEZn8fansRBwrujRt2lTvJtr5+fno169ftXnv2LED//rXvzBixAj85z//rJWF3wABAABJREFUMblO+/btsWrVKvz5559o1aqVyccBoF69eggMDDR542ag4kZmQPVlXhX3X375Rc/dGkT2tkd/VudYqYzq7s/qzNye/WmPzGuqP6szc3v2Z01lXl5eLven4SV9RMzcUodqtVqUlZUJ6a2LCP1pLU5OTmjTpg2uXr0KT09Po8d9fX3h5eUFjUYjnLs1iJi5RFlZGQYOHIigoCDs2rULQUFB8mMie5tDif60lmvXroGIkJqaatSfiYmJCA8Px5YtW4TzNoe0f1SiP63FyckJ/v7+yMzMRElJCVxdXeXHpP5v1qyZcN660H8vqdK7d2+jiXsRM8/KygIRme1PrVYLf39/4bx1adCggd7lSW/evIkxY8bYPW+tVotJkybh4MGD2Lx5Mw4dOmS0jqj9qes+YMAA7Nmz575eT8nMK/MWqT8Nx8pDDz1k0+sUFhbqHThbFf4R91hwdnbGyJEjsXXrVpw9e9bo8YyMjBp3+OabbxAdHS0fpQsAOTk5SE9PR8OGDbFz5075CDpRvKUjonS9y8rK5Bl+XU6cOAHg3tFTSrsDxpk///zz6NOnDwIDA7Ft2zZs27YNK1asAAC0a9cO27ZtQ5MmTYTLvKioSH4TpMs777wDoOIoAEDMzIGK69OVl5dj//79euteuHABDz/8MNRqtZDeEhs3boRWq8X48eP1liudt6mx0qRJEzg5OeHq1at660pHFktfcivtDljOXEKaCHFxccHUqVOrxfvIkSMYO3YsevXqJR8JZIphw4ZBrVbLZ4UA9z5M1atXDz169JCXjxw5Ejdu3NC7RuHBgwcBAK1btwZQPZlXxR0APvvsMyP3yhDV2x79Wd1jxZ79Wd2Z26s/qztze/ZnTYxze/RnTewTJe7evWuyPwExM5fGw927d42+HElOTkaHDh2E9DaFkv1pC6NGjUJWVhZKSkrkZX/99RcAZfqzOhHVu7CwEGlpaXBycsLevXsRGBjoEN7p6elGy6QzAJToT2sZO3asUX9u27YNQMU+Z9u2bejRo4dw3uZed/ny5bI7IGbmAORJHOmeEBKJiYlo1aoVQkNDhfSWKCwsxJ07dxTvT2sJCgqCWq1GQUGB3v4cqNint2jRAp6ensJ5W0Kr1eLFF1+0e97PPfccNm3ahGXLlmHEiBFm1xOxP3XdpTOy7wdRvUXrT2vHirn+PHjwIDp37lypkzX8I85YAICFCxfi8OHD6NatG55++mm0atUK2dnZOHXqFA4cOCDf1NQciYmJ+PbbbwFU3MAwJycH8+fPB1DxoXrIkCEAKj54jB49GkOHDkVwcDASEhIAVJzyIt1cEqiYLd+3bx+0Wi0mTpwo3xhWeq3jx48jMjJSMe9z585hx44dAKDnnZ+fj9DQUPn06hUrVuDMmTPy0dO9evUSNvOOHTuiQYMGuHLlCh5//HEA996QBgUFyctEyzw1NRUdOnRAnTp1kJeXh6VLl2Lv3r3YtWsXAKBFixbCZg4Abdq0wcWLFzFy5EjMnDlT/iJZq9XK64roLREfH4+QkBD07t3b6DHRxkpgYCCmTJmCVatWwd3dHZ9++iny8vLkLyV69uypuLulzE+cOIGsrCwsX74cpaWl8g2RBg8eLB9BUhXv5ORkDB06FCqVCqNGjcLXX3+t93jbtm3l0xPr16+PF154AYsXL0ZpaSm6dOki76cXLVqkd2r1q6++iri4OKSmpiI2Nhb5+flYvHgxAP0jSpVyv3TpEgDg6NGjiI+P13PPz8+X/99JN9QGKt7UrF27FhMnThTO2x79WRNjxV79WROZ26M/ayJze/VnTW2fNd2fNbVPlLh7967Z/hQx88DAQDRt2hSXLl1C3759MWLECHliqqysDK+88oqQ3oBY/QkAa9euRXJyMgoKCgBAvjzj/PnzMXHiRISFhQEApk2bhgULFiAtLQ2LFy+GWq3GRx99BADyGZpKu0veAPTcS0pK5P48duyYvO6RI0fw6aefYsaMGUJ679+/H2VlZZgwYQISEhLk92WJiYnYv38/+vfvL+RYadOmDTw8PJCbm4uVK1fi0qVL+OKLLwBA78hQ0TJv0aKFUX9K+Pn52b0/bck8LCwMISEhyM3NxbJly5CQkICNGzcCgN6XUaJlDgDNmzfH77//junTp+PixYvyfjAnJ0feP4qYucTdu3fh5uaGkSNHmnx90TJ3dnZGREQETp8+je7du2PSpEnyAVd5eXnypVxE8waAM2fOIDMzE7GxsXBxcZEvO9SnTx906dLFrt5LlizBsmXLEBkZCY1Gg3Xr1smTBevWrcPw4cPly3mJ1p+G7rreAPTcRepPW7xF6k9TY0UXXe82bdqgb9++aN++Pfz8/OT+LC0txcKFC8362ES13KnBDlTl5s0SaWlpNH36dAoNDSW1Wk3BwcHUt29f+vzzzyt9/bi4OLM34IiKipLXy87OpmHDhlFwcDC5urqSl5cXAaDc3Fy955NuemjNcyrhHR4eTh07djTKvLi4mGJiYsjPz49UKhWp1WoKCwuj6Oho4TMnMh4rhjefVNLbXOa3b9+mCRMmkJeXF6lUKnJzc6PWrVvTu+++6zCZ16tXj4YPH07e3t7yzZH+9a9/Ce8dEhJCAGjmzJlEJM5+xdxYIaq4SVzXrl1JrVaTp6cneXp6Up8+fYRxt5T5Aw88QGq1mjw8PMjLy4v69u1brd6HDx+2uN81fJ3y8nJ69913KSwsjFxdXcnf399sDw0bNozc3d1Jo9GQr68vjR8/Xhh3JycnAkDr1q0zet5HHnnE7HM+9NBDQnrboz9rYqzYqz9raqzUdH/WROb26s+azLwm+7Mm94mPP/64Xn8SVW+H1lTmEydOJH9/f2rfvr3coQBo0qRJQnuL1p8PPfSQ2XUPHz6st+6oUaNIo9GQt7c3eXp60uDBgx3CfeTIkWbX091XiuZt6TmV6H1rvefNm0e1a9cmJycncnFxoZCQEBo7dqxDjBVz31VIN28W1ftf//oX+fj4yO9ZmjRpQnPmzHGYzENDQykqKor8/f3lm9uPHz9eaG8ioieffJIA0IgRI+RljpJ5QEAAde3alXx9feX3LE888YTQ3n379pU/o2o0GurevbtieUdFRVlc9+rVq3rPLVJ/2uIuUn/a4m1pPXv3py3e8+bNo86dO5Ofn59efyYmJlr0sQXVfwNiGIZhGIZhGIZhGIZhGIZhGIaplH/EPRYYhmEYhmEYhmEYhmEYhmEYhqkeeGKBYRiGYRiGYRiGYRiGYRiGYRir4YkFhmEYhmEYhmEYhmEYhmEYhmGshicWGIZhGIZhGIZhGIZhGIZhGIaxGp5YYBiGYRiGYRiGYRiGYRiGYRjGanhigWEYhmEYhmEYhmEYhmEYhmEYq+GJBYZhGIZhGIZhGIZhGIZhGIZhrMZFaQHRUKlUZh8jIjua2IajegOO6+6o3gDQQ6XCT7o/Azj+37+L7O6omTuqN+C47o7qDTiuO3vbH0d1d1RvwHHd2dv+OKq7o3oDjuvO3vbHUd0d1RtwXHdH9QYc15297Y+jujuqN+DY7obwGQsM8w9krYmf6yshwjAMwzAMwzAMwzAMwzCMw8ETCwzzD6QxgL9RcabC3//9+Qfw5ALDMAzDMAzDMAzDMAzDMJXDEwsM8w/kbwC9UXH5o97Qn1xgGIZhGIZhGIZhGIZhGIaxBE8sMMw/kN4Abvz37zdwb3IhXSEfhmEYhmEYhmEYhmEYhmEcB755M8P8A7lh4ueHAOQByLG/DsMwDMMwDMMwDMMwDMMwDoSKHO120wzDMAzDMAzDMAzDMAzDMAzDKAZfColhGIZhGIZhGIZhGIZhGIZhGKvhiQWGYRiGYRiGYRiGYRiGYRiGYayGJxYYhmEYhmEYhmEYhmEYhmEYhrEanlhgGIZhGIZhGIZhGIZhGIZhGMZqeGKBYRiGYRiGYRiGYRiGYRiGYRir4YkFhmEYhmEYhmEYhmEYhmEYhmGshicWGIZhGIZhGIZhGIZhGIZhGIaxGp5YYBiGYRiGYRiGYRiGYRiGYRjGanhigWEYhmEYhmEYhmEYhmEYhmEYq+GJBYZhGIZhGIZhGIZhGIZhGIZhrIYnFhiGYRiGYRiGYRiGYRiGYRiGsRqeWGAYhmEYhmEYhmEYhmEYhmEYxmp4YoFhGIZhGIZhGIZhGIZhGIZhGKv5n5hYmDx5Mho2bKi3TKVS4c0331TEx1oc1RtwXHdH9QYc15297Y+jujuqN+C47uxtfxzV3VG9Acd1d1RvwHHd2dv+OKq7o3oDjuvO3vbHUd0d1RtwXHf2tj+O6u6o3oBju9ckwk4sqFQqq/788MMPNe5SUFCA//znPxgwYADq1q0LLy8vdOjQAcuXL0d5eXm1effv3x8AsGvXLrt7X7hwwWr3yZMnY82aNUhOTtZbXp3UdOabNm1CZGQkPDw8AABffPEFDh06ZFdvWzIPDg42m/nSpUur7G2ru62ZFxUVoU+fPggICICvry8A4I8//hDe++7du+jYsSPc3d0RGBgov569vW/evGmTe0FBATIyMuDr6wtvb28MGzasWpzvx90W75ycHGRnZ6NHjx5wd3dXdL9iS+Zvv/02fvzxR6SkpECj0aB58+aYNWuWYu62ZH7t2jWkpaUhJCQEbm5uqF+/PgAgPT1daG9DlOxPW8YK92f1eNuSOfdn9Xjb2kNXr17FrVu35P6Mjo6uFuf7cbc189LSUgwcOBCenp7w9/cHUPF+QGTvzMxMZGdno1OnTlCr1YruV2xxnzt3Lg4ePIgbN27Aw8MDERERmD9/vmLutmR+8eJFpKamok6dOnBzc0N4eDgA4M6dO3b3ttVdorS0FK1atXKYHkpISDC5L//000+F9pZYvnw52rdvj1q1agEA1qxZUy3785oaKyqVymx/fvXVV1X2ttXd1swLCgrQvXt3+Pr6onbt2gCAixcv2t3bVvc///wTKSkpcHNzQ7169TBz5sxqcb4fd+5P+3onJSVxf9rZ25bMRetPS+4bN27UW3fy5Mkm12vRokW1eLtUy7PUAGvXrtX7+auvvsL+/fuNlrds2RIrV66EVqutMZcrV67gueeeQ9++fTFz5kx4e3tj7969mDZtGn7++WesWbNGXvfRRx/Fjz/+iC5duqBRo0ZISEjApUuXoFKp8PLLLyMiIsKk9zfffIPjx48r5r1q1SpoNBrZu7CwEDt27EBhYSHmzJkjewPA77//DqDiA7mfn5+8fOLEiYq425r5W2+9hXHjxmHUqFGYPHkypk6dijp16iAlJcWu3rZkXlZWBgAgIqjVagBAcnIyXn/9dTRu3LjK3ra625L50KFDsWbNGjRu3BhvvvkmVCoVZsyYge3bt+Pjjz/Giy++KKR3586dsWbNGrRr1w4fffQRbty4gffeew9r1qzB22+/DXd3d7t5Z2ZmokWLFmjWrBlq166N8vJy7N69GxkZGRgyZAhGjx4tr9ugQQOcPn0aHh4emD17NtRqNT7++GMA1TcpYov7ggULsHbtWtn9+PHjuHDhAgDoubds2RKDBg3Cjh07kJeXh5YtW8r7muqipjJ//vnnUa9ePbz00kto1KgRzpw5I3/ILS0ttbu7LZn37NkTtWvXRufOnREQEIDU1FS8/vrrWLlyJZ555hm0a9dOSG+R+tOWsSJaf9qauSj9aUvmovWnLZmL1J+2ZP7LL7/gyJEj6NOnD0aNGoUbN27gk08+AXDv/0dVscVd97NDUVERZsyYgeLiYri5uWHVqlXyYy1btsS8efOwc+dOXL58Ge+++y7y8/Px2muvYe3atViwYAFcXV2F9O7QoQP27t0LlUqFRo0aVduXZ/fjreteVFSEl156Cbm5udBqtUb/pqeffhpdu3bFv/71L4SEhOD48eOYN28egIpt1t7utmTepk0bNG7cGO3bt4efnx+uXr2K+fPn4/PPP8fLL7+MkJAQu3nrulvKXHKXOjQ2NhbXrl2rkmdV3W3JvEePHrh+/Tq++OILefnEiRPlgwtE9V65ciWmTJmC559/HpMmTcKMGTPw9NNPw8fHp1oO5KipsZKTkwMPDw+9/jx58iQ++eQTRfrTlszbt2+PNWvWoGvXrli4cCGKiorw4osvYsOGDRg1ahRGjBhhN29d98oy37JlC06cOIHhw4djwIABOH/+PGJjY6vkWhX3jz76CDNnzkT37t3Rvn17JCQk4OzZs5g6dSqaN2+OgIAAAOL1py3eovUnANkbgOz+8ccfy94i9qctmYvWn0DlmUvuIvWnxLhx4/DYY4/pLYuMjDRaz3BfCQA+Pj7VI04OwvTp08kWXQA0b968anntjIwMOnv2rNHyp556igDQpUuX5GUnT56kvLw8+WfJOzAwkB544AGTz19YWEgNGzakt99+mwBQly5dFPcmIoqOjiYARt7z5s0jAJSRkaG33BEyP378OKlUKvroo4+E8yYyn7kp3nnnHQJAU6ZMqbo41Vzm/fv3p5CQECoqKpKXASA/Pz9q27atkN7FxcXk6+tLvXr1Iq1Wq+cNgJYuXWpXb1NI7h4eHlRWViYvf//99wkAnThxQl72559/EgB68MEHq+xdVXfJe/DgwUbuWVlZlJubS0REixcvlvNWYvu05G7offjwYaN116xZQwBoyJAhVfYmqrnMTQGAVCoVPfPMM8J7i9CfltwNvUXrT3PepjIXqT8tuVszxpXsT0MsZS5Sf1py1/U215/fffcdAaCBAwdW2bsq7nPmzCFfX1/Z25Bnn32WatWqRcnJyfIyqYtWrFghrHdqaioVFBQQ0b3/LyJsn3PmzKHmzZtTs2bNjD7HFRcX07Fjx4x+56233iIANHHiRMXdLWVuCin39957r0rORDWTuS5paWnk4+Mj96co48VS5lFRUUbLHcF706ZNBIC++eYb4bytGSu6SJ9VX3zxxSo5S9RU5k2bNqUuXboYfY5Tq9U0dOhQRb3NZX7z5k1ycXEx2vfFxsYSABo7dmyVvW11v3r1KgGgxYsXE5Hl7+RE6k9bvEXqT0Nvc+4i9qctmZtCqf60NnNdROlPU+7mMNWf1Ymwl0KyBVPXuTJFSkoKpkyZIp9y07p1a6xevbrS3wsICEDr1q2Nlg8fPhwA8Oeff8rLOnXqBE9PT6N1e/bsqbeerveiRYug1Woxe/ZsobylI7INvSU6duyI3NxcizOiomU+btw4ODk5ISYmBkSE/Px8obwtZW44ztevXw8ACA0NFcIdMJ356dOnkZGRATc3N73lGo1GPhVYNO+zZ8/izp07OHv2rNHpbWq1Wu/UMnt4W6KgoAAlJSXyz1u2bEHt2rXxxBNPyMukU9zOnTun97tKujds2NDIfebMmWjTpk2lvyta5r179zbaPqXnzMjIEMbdVObm+lOtVuudjiqqtwj9aQlDbwlR+tMcpjIXqT8tYSpzkfrTHKYyF6k/LaHrLfVncXGxfGo7AAwePFh+XBd7ul+6dAkff/wxHnzwQbPPGxcXB5VKhQYNGugt9/f3x+bNm4X1njNnDlq2bFnp6yvh/dFHH5m8VICrqyt69OghZH9ak7mlz59K9Wdlmeu6N27cGM2bN8eECRPMrida5gkJCSgoKEB5eTlyc3Mdxnv69OlwdXXF8OHDodVqzV4aRtSxIo3z4uJibN26FQDg7e2tuLulzK9fv27yc5yrq6ti/VlZ5sePH0dZWRlu3rypt28ZO3YsAGX7E6i4pJGpyzxJiNif1niL2J+St6nPEIDY/Sm5W8pcxP6UvM1lrusuWn9a6w6g0v68X4S9FFJ1k5aWhu7du8unkQcGBmL37t2Ijo5Gbm4uXnjhBZufMzU1FQD0To+xtK6p9crLy7Fw4UKsXr1ar+RE8ba03o0bN+Dj4wMPDw88/vjjwrmbyvzWrVtwdXXF0qVLMX/+fGRlZQEATpw4IYy3NeudPn3a5E5FaXdTmQcHByMzMxNvvPEGoqKi5DdSN2/elK9vLZp3cXExAJh806dWq3H69GlotVpkZGTY1buwsBB3795Ffn6+fOmMyMhIed+h1WqRmJiIhg0boqioyOj3b9++jby8PHh5edk9c8ldKrK4uDg9d2tRyttc5pU9p0ajUdzdmszv3LmD0tJS+flKSkrQt29fob1F609bxopo/WlN5iL25/1sn6L0pzWZi9iflWUu9aeLi+mPGKmpqdBqtXBycrK7+wsvvIA+ffogLCzM5O+mpKSgqKhI7zJlEvXq1cPp06cB2D/zyrytRSnvxx57zKZrhIvQn7ZknpWVhfLycr1LIijVn9ZmnpmZifz8fCxZssTsl8qiZk5E8Pb2RkFBgbyt6n6ZIpp3bm4uMjMz4eXlhVdffRWxsbHyxLzuAT+ijhVddu3aZfIa6KJlDlT0Z1JSEmJjYzFkyBD5c1FxcTFiYmIU9TaXubn+lPaFt27dkpfZ2/2tt97CSy+9JP+8b98+DBgwQP5Z1P6szNtalPJWqVRWf3+k+5xK9qctmYvUn9ZmLmJ/6rp36tQJCxYsMJl5QUGBXn+OGzcO77//vskDb22mxs6FqGYsnY4SFRVFYWFhestgcDpKdHQ01a1blzIzM/XWGzt2LPn4+MinP1lLcXExtWrVisLDw6m0tLRSb5VKRW+88YaRt0ajoR49euh5617KQSlvIqLhw4cTACPvJUuWUIsWLSggIIC2bNlCMTEx5OLiQgBo7ty5irubyzw7O5sAkJOTE3l6etLixYvlU1MB0GeffaaoN5H5zIn0x/msWbNMnnYlWuZEROPHjyeNRkMqlUp2BkBjxowR1jsjI4MAkKenp976uv6ZmZl2937vvff0HADQtWvXjLzbt29vcp8IgC5cuEBE9s/c0L1v37567kT6Y9zcpZCU9jbM3JS75AmAZsyYIYy7pcybN2+ut27Pnj2pvLxcaG/R+tOasSJqf1aWuaj9eT/bpyj9ac04F7E/rekhlUpFTZs21dsnXrhwQa8/7e2+c+dOcnFxoXPnzuldwkmXX3/9lQBQQECA3nIA1KNHDwJARUVFwnkT6Y9xc5dyUMqbiOSOMYVhf/br148A0Jw5cxR3tyZzNzc3ve1B93JfImau1WopICBA/jdJl1IQZbxYyjwiIoK8vb1p06ZNtGHDBoqKiiIAFBoaKj+naN6nTp2S+7NOnTq0bNkyio+PlzPfvXu3ot5E1m+fI0eOlMe76GNlzJgx5O7ubtRXupdAFC3z3377jQBQhw4d9PaJe/bsIaDiMk72dk9OTqYBAwbQ8uXL6dtvv6UHH3xQHs87d+6U1xOtP631JhKrPw29lyxZQp6engTAyNvQnUjZ/ryfzEXoT1syF60/Tbk3aNDAZOZz586lOXPmGPXnAw88UOl3lNbwj5hY0Gq15OvrS//3f/9HGRkZen/i4uIIACUkJNjk8/TTTxMA+v777y2uN2XKFAJAjRo1Mrqe/iOPPEKA/rXQdb8YUdI7LS2NPDw8CICRN5Fx5tIbpL59+yrubi7za9euyRv+xo0b5eVSCdavX98hMi8vL6d69epRhw4dHGKcT5w4kXx8fOiJJ56gDRs20Lp16+Q3R8ePHxfWu2HDhgSAPvjgA/r777/pyJEjcjlKX6TY2zspKYn2799P69evp6ZNmxIA+uuvv+THpTHeqVMnsxMLp0+fViRzyb1///7yvkLXnajyiQUlvc1lbspd9wOjCO7WZP7TTz/Rnj17aNmyZQSAIiMjqaSkRFhvEfvzfsYKkRj9WVnmovanrZmL1J/WjHMR+9OazMeMGUMqlYr8/Pzk/mzXrp08hq5fv25X9+LiYmratKk80Wvuyyip5wMDA/WWA6BevXoRAMrOzhbOm6jyL0aUzJvI+i8uFyxYIJS7NZkfOnSIdu3aRR9++KFi+3JbMl+9ejU5OztT/fr1icj0FyOiZ66L5L5hwwYhvaX9CgD6+eef9bxr1apFDzzwgLBjhehe5jk5OeTu7i4fBCf6WHnyySfJy8uLoqKi6Ouvv6bVq1fL6166dEnYzLt160YuLi5Uu3Ztunr1Ku3atYvCwsIIqDgQjkjZz/xS5nXq1KHmzZvLy0XrT2u9icTqT1NIB6sZehu6K92fhliTuQj9aQpzmYvWn6bIysoymbkppDGzYcMGm3xM8Y+YWEhLS5P/h5v7o3szpcpYtGgRAaB33nnH4nr5+fkUFBREAOjMmTN6j5WWlpKvr6/JG1BJX4wo6d2lSxdydXW1OfPw8HDF3c1lnpGRIb+27s0RAVDv3r0JgHykgMiZHzp0iICKL7xFH+dERM2aNSO1Wi0f/UxUkbm/vz917dpVWO9x48ZRrVq1jFxatGhBAOjixYuKeEtI+8TQ0FB51lsa45WdsaBU5rreTz/9tJ47UeUTC0p667obeuu6HzlyhNzd3eUvvkVwtzZzCaDig9esWbOE9Ba5Pw3dLY0VQ3el+1PX2zBzkfvT0N1S5qL1p663qe1T1P40dDf0vnPnDoWGhup5TJgwQf777du37eq+cOFC8vPzo6ysLD3v+zljQXeSTRRvosq/GFEybyLrvrjcuHEjqVQq+QO9CO738yW3s7MzxcbGCpl5Tk4O1alTh9q1aye7m/pixNEyB0DR0dFCekv7FRcXFyPv9u3bk1qtppSUFOHGioSUufTF/JYtWxxirISEhFCtWrX0lgEgd3d3Gj16tJDbJxHRjRs35M+n0v7kpZdeIgDk5uZGRGK8Z5k7dy4BFQcKEInXn9Z6E4nVn5bcDb113UXoT3PelWUuoVR/WnLX9RaxP81hKnNTFBQUkJOTE0VHR1v93Ob4R9xjQavVAgAmTJiAqKgok+u0bdvWquf68ssvMWfOHEydOhWvv/662fVKSkowYsQIZGZmAgAiIiL0Hv/qq6+Qk5ODOnXqICkpSe+x4uJiJCUlKeqdmJiIxx57DNu3b7fq+SUKCwsBiJm5v78/nJwq7lfu7Oys95iHhweAimvQK+Vtbebx8fFwcnLCuHHj9G5YKmLmJSUluHTpEry9veXsJZo0aYKTJ0/K17wUyRuouClSUFAQjhw5gqSkJISFhaFhw4bIz89HYGAgvLy87O5tiuvXr+PIkSN45JFH4O/vDzc3N3k7NEVISIh80zgl3UeNGoWVK1fK7tagxBg3hW7mupSUlGDo0KGIiIjAli1b5DEiirstmYeHhyM+Pl7ex4jkLWp/msLcWDGFkv1piGHmovanKSxlLlJ/GmKYuaj9aQrDzH18fPDwww/j4MGDiI+PR1hYGMLCwrBu3TpoNBr4+vrK14qtafecnBzMnz8f06ZNQ25urvwHAIgISUlJ0Gg0CAoKQt26dQHA5A0H8/Ly4O/vD7VaLZy3NdhrjJvyBoDS0lIAMOtdVFSESZMmYdCgQfjss8/wxRdfCOF+P5nXrVsX8fHxGDVqlGLegOnMP/jgA5SUlKBhw4Y4efIkkpKScOPGDfm57ty5g5KSEofLXKPRIDs7W0jvkJAQADDajwMV/VlaWirfc0GksWJIfHw8fHx8MHjwYL3lImZ+5coV3Lx5E7Vr1zZ6jQYNGuDYsWPC7hPr1auHRx99FAcOHMCGDRvQtGlTBAcHY/HixfK/R4T3LKGhoQCA7Ozs/2fvvuOjqPM3gD+bZNN7hVBCgAABlFAFVARBxAJIUUBFENRTQIPY0PMEpchZURQEFEREREEsiAIqFhCPA1RE9AAhCS2hBFII6Z/fH7kZdje7m1mS7H73d8/79eJ1MplsHj733X2SzM4MGjdurFR/upLbCBXmrbGXW4X+dMaVmbu7P43QcqvWn84YnXlQUBBiYmKQm5tr+LEdqvWhCTepzRkL5eXlEhYWJqNGjapVho8//lh8fX1l2LBhVu8es1VRUSEjRowQX19fGTBggN3c06ZNq/FI1urVqz2We82aNS7NvLKyUoCqS8qIqDlzEZHY2FgBICUlJfo24MIpellZWUrPvGnTphIZGSlXX321nl3ldX7s2DEBIOHh4VbbAUiXLl0EqLrsk2q5RRy/rvj4+MioUaPcPm9blkfSV61apW/v0qWLxMTE2M0eGRkpIu5fK/Zyf/zxx9Wy13TGgqozFxEZOnSo+Pj4SKtWreTEiRMi4tnnp73cNc1cA1Sd+hkUFKRkbhX701F2e2tFtf60l9veWlGtPx1ldzRzlfrTXm7bmavYn46yG1nnZ86cEQDSvn17EXHfzC3fTeboz+DBg/X9AwICJDg42OoxgKqzRK6++mplc9f0jktVc4uIXH/99WIymaRnz576mS/ekN1RfyYkJEhqaqqSubVrKjv78/PPPyuZXcvv6IyFe+65R9ncgYGB4uvrWy33pZdeKoGBgVJaWqpkbpGqmTdu3Fh8fHz0+xOo/vz88ccf9ddtSwCkZcuWkpCQoGRuje06//333wWAXHHFFSKixvcs2v2qjh07pn9Mlf50Nbcq/VlTdtvcIur0p7PcNc1c44n+rCm7ZW7V+tMZezO3Jz8/X0wmk9xzzz21iSoi/yOXQhIRGTt2rPj7+9u95In2SyBnvvvuOwkMDJQ+ffpIcXGx030nTJggAGThwoUOc//xxx/Sp08fiYuLk7Vr1+p/tMJbu3atHDt2zGO5RRzP/MSJE9Vm/vrrrwsA6d+/v75NtZmLiHTt2lUAyKJFi/RtQNUvXNu2bevR3CI1r/O4uDgBIG+99ZaeXeV1Xl5eLmazWfz8/Kr9MiosLEzatGmjZG4R5z+8aNd1d1due49leePp/fv369vnzJkjAKRhw4b6Nu2mmZdffrm+zVPZtdwDBw6slr2mAwuezG2Z3Tb38ePHJTQ0VHx9feXQoUP6dlWyO5v5iBEj7K5zf39/ufLKK5XMrVp/urJWVOtPV9aKSv3pysxF1OpPozNXrT8vZuaW6/zee+8VAHLXXXfp29yR/dy5c1avE2vXrpXrrrtOgKpLYqxdu9bquuetWrUSk8lkdUNqrYsWLFigbO6afjHiydxr166VRo0aCYBquffu3SsBAQFiNpslNzdX365KdkczLysrk1GjRtntT5PJJKNHj/Zobkcz37lzp6xdu9aqQxcuXKivlxEjRsjZs2c9mt3RzM+fPy+33nqrw+/NtUtLqJZbRCQ1NVUAyMaNG61y+/v7y/XXX+/R3M6enyJVry1RUVECQL7++ms9u8rPzxMnTghQdemgyspK/TGAqnsUaTeIVXnm2jqvqKiQG264QQDI5MmT9X08/T1LVFSUXHrppVYfU6U/Xc2tSn86eiztF9q2uVXqT3uP5WjmKvWno8eyN3PV+tPRYx05cqTazM+fPy/5+fnV9tUus+bKpZkc+Z+4FBIAzJkzB5s3b8Zll12Gu+++G23btkVubi527dqFr776yunpH5mZmRg0aBBMJhOGDx+ODz/80Orjl156qX46y9y5czF//nz06NEDwcHB+M9//gMAePfddwEAQ4YMQUhICNq0aYOmTZvi4MGDuOmmm6weLyoqSt/mqdzvvvuuVXYtNwAkJSUhMTER+fn5mD9/PrZs2YL3338fANClSxdlZw4ArVu3xi+//IKJEydi3759aNq0KYCq0xTfe+89ZWeuOXfuHAICAjBs2DC7X1+1mfv6+qJ9+/b4+eef0b17d9xxxx36KZIFBQX6KV2q5QaA3377DadOncK8efPg5+enX6KqT58+6Nq1q1tzz5o1C1u3bsWAAQPQtGlT5Obm6vtPmjQJLVu21D9vwoQJmDVrFnJycvD888/DbDbjpZdeAgD06NFD389T2Xft2gUA+Oyzz3D//fdbZS8tLdVPGd66dau+/fvvv8drr72GSZMmKTnzAQMGoLCwEOHh4diyZQu2bNmif+yvv/5SeuaffPIJfH198dxzzyEqKgr79+8HUHUq85w5c5TMrVp/urJWVOtPV9aKSv3pysw1qvSn0Zmr1p+uzHzOnDn44YcfUFBQgAULFuDjjz/Gxo0bAVRd5sGdMw8ODq72OvHVV1/pM7b92KWXXooDBw6gT58+SE9P1y9REh8fjzvvvFPZ3IWFhXp/7tixQ9/+/fffY/ny5Rg9erTHcgPA1KlTAcDqYwUFBbj22mtRUlKCyMhIfP7551afc/jwYf2/VZt5YWEhPvzwQwQGBuKll15CSEgIfvvtNwBAQEAA/vGPf3g0N2B/5p06dUKnTp3w8ccf6x1qeUnBNm3aICIiwqPZHc08Oztbn/mrr74KANiwYQMAoEWLFhg8eLCSuQHgkksuwb59+zBs2DBMmTJFn3FlZSVmz57t0dyA/bVi6dy5c0hMTETv3r3tfly1mcfFxSElJQX79+9H3759MXToUBQUFAAAysvL8fjjj3s0N+B45unp6di2bRsKCgrw6quv4r333sP27dsBQF837soOAI8++ij++usv9O3bF4mJifjpp58AVK2JV155pdrnqdCfruZWpT/t5c7IyNB/TrDMrVp/ujJzlfrTlZmr1p+Osi9cuLDazLOzs9GxY0eMGjUKbdq0AVDVn+vXr8eAAQP0/qyVWh+acJPanrEgUnUjjYkTJ0qTJk3EbDZLgwYNpG/fvlbvvrNn8+bNTk95sfw6NZ0iY/luVke5tZtPqpr7rrvukoiICDGZTGI2m6Vly5by2GOPec3MmzRpImPGjJHo6GgJCAgQAHLbbbcpnVtE5NZbbxUAMnToUH2bt8w8NjZWunXrJpGRkfoNkW+++Walc/ft21f8/f0lLCxMgoODpXv37h6b98aNG+XGG2+UxMREMZvNEhYWJg0aNBAAVu/E0QwfPlyCg4MlPDxcQkND5cYbb1Qmu9lsFgCydOnSatmHDRvm8DEtXytVm7mzx7R9jVdt5h06dBB/f3+JiooSPz8/SUxMFABy7733Kp1bpf50Za2o1p+uzlyV/nT1NVGl/nR15qr0pyszX7duncTGxorJZNL784MPPvDYzG3VdHPYxMRE6d+/vwQHB0tkZKQAVafyq5z72muvdfiYV111lUdzi9i/UWlNlwjp0KGD1f4qzbykpERSU1PFbDZLeHi4mM1mSUpKEgCSnp7u8dwixm7IK2L/5pOezO5o5mfOnJHmzZuLn5+fBAcHS0BAgLRr104AyJNPPqlsbpGqeTdq1EiGDBki4eHh+mu55Rlcnsot4nyt3HTTTQJApkyZom9Tfa2IiIwePVqio6MlLS1NQkNDJTQ0VADIHXfc4fHcIo5nvnTpUomKihKTySRhYWHSt29f+eabbzw28/fee0969eolcXFx4ufnJ4GBgQJAdu7cWe1xVepPV3Kr1J+2uWNjY6V58+Ze0Z9GZ65afxqduUal/rSXfciQIdVmfubMGbn99tulZcuWVv05e/ZsKS0tdZrHKJOICIiIiIiIiIiIiIiIiAzw8XQAIiIiIiIiIiIiIiLyHjywQEREREREREREREREhvHAAhERERERERERERERGcYDC0REREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIb5eTqAakwmk8OPiYgbk7jGW3MD3pvdW3MD3pudud3PW7N7a27Ae7Mzt/t5a3ZvzQ14b3bmdj9vze6tuQHvzc7c7uet2b01N+C92b01N+C92Znb/bw1u7fmBrw7uy2esUBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESGmcTbbjdNREREREREREREREQewzMWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDOOBBSIiIiIiIiIiIiIiMowHFoiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsN4YIGIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLDeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIsP8XBxbGjh2LZs2aWW0zmUyYPn26R/IY5a25Ae/N7q25Ae/Nztzu563ZvTU34L3Zmdv9vDW7t+YGvDc7c7uft2b31tyA92b31tyA92Znbvfz1uzemhvw3uzM7X7emt1bcwPenb0+KXtgwWQyGfrz7bff1nuWoqIivP766+jfvz8aNmyIsLAwdOzYEQsWLEBFRUWtcy9YsABpaWkICgoCACxbtgy//vqrW3NnZGQYzm4ymbBs2TJkZmZabQOAd955p9a5Xc3u6syLiorQvXt3REZGIiYmBgCwb98+t+d2Zebffvst/vjjDxw9ehQBAQFo1KgRpkyZUieZLya7qzMvKyvDgAEDEBoaiujoaADAuXPnlM596tQp5ObmonPnzjCbzfoaryuu5HYl+9SpU/H111/jyJEjCAkJQfv27TFz5kyPZXdl5vv27UN2djYSEhIQEBCA5ORkAMDZs2fdntvV7JqysjK0bdvWo+vFldxbtmyx+1r+2muvKZ1bo0J/upKd/Vk3uV3Nzv50b26V+nP69OnsTzfndmXm7M+6ye3qzEUEBQUFen9qr+fZ2dluz+5Kbkf9+fTTT+Oaa65RNrf22Cr0p6trhf1Z+9yuZF+wYAF++uknHD9+vF7609XsRnN/8803OHDgAE6cOIEmTZroHQoA5eXlyuZWrT9dza5hf158blezq9SfAHD8+HHcc889SE5ORlBQEFq0aIEpU6bg9OnThv+NddGffrV+hHqyfPlyq7+/88472LRpU7XtqampWLx4MSorK+sty8GDB3H//fejb9++mDJlCsLDw7FhwwZMmDABP/30E5YtW6bv+9JLL2HKlCno3r070tLSsGXLFuzZswf33nsvWrdujdjYWKvc48aNwwMPPIA77rgDkyZNwt13342IiAicOHHCrbk1Wm4AevaXX35Zzw0AeXl5CAkJgYjAbDYDAHbs2IFXXnkFLVq0qHVuV7O7MvO0tDQsW7YM3bp1w5w5c1BcXIwHH3wQK1euxPDhwzF06FC35dYYmfnq1auxfft2DBkyBP3798fevXsxb968WmWtTfbly5cjMzMTs2bNQlRUFEJCQrB//34MHjwYubm5uOeeewBUzXzatGlYt24dDhw4gNmzZ6OwsBB///vfsXz5csyaNQv+/v5K5u7YsSM2bNgAk8mE5s2b19k3/xeTGwBmzpyp577yyivx22+/Ye/evbjyyiv13MXFxbj77rvRrVs33HXXXUhMTMS2bdswbdo0AICIuD27KzO/5JJL0KJFC6SlpSEqKgqHDh3CzJkzsWjRIjz66KNITEx0W27A2My17FoPzZs3D1lZWbXKWdvsrsy8Z8+eOHz4MN566y3980ePHl0n32DUZ27V+tPoWlGtP12ZuWr9aXTmqvXnrFmzcPjwYf3vWu9HR0ejuLgYr7/+Ovz8/JTrT1dyq9SfQ4cORU5OjtXna9mDg4P13Cr2pyszV6k/jc4cUK8/XZm5Sv3p6sxFBHl5ebjpppswadIknDt3DpMnT66zX7rW18yXLl1q1Z9A1cwBoH///srmVqk/XVkrqvXn4sWLMXXqVJSUlKBfv37Yt28f9u7dC19fXzRq1AgzZsyAj4+Pcv1ZWFiImJgYPXdMTAw2btyIw4cPo2nTpnpuAPjll1/w119/4ZJLLsG5c+fqvD9dzW505s2aNcPWrVvRrVs3DBo0CPHx8di2bRt+//13vPvuu5gxY0atf+ldX2tFpf50Za2o1p+uzFyl/nR15ir1Z2FhIXr06IFz585hwoQJaNKkCX799Ve89tpr2Lx5M3bu3Klnt/09OnDhZ9C66E+Il5g4caK4EheATJs2rU6+9smTJ2XPnj3Vtt95550CQPbv369vO3TokACQ559/XkSc5161apUAkI8++ki53DVltzV+/HgBIA8++GDtg0v9zTwlJUW6du0qlZWV+jYAYjabZdCgQR7N7Sj7sWPHxM/PT0aPHm21fd68eQJARo4cWevcrmavqKiQ9u3by2WXXSZFRUVOZ37fffdJUFCQZGZm6tsACABZuHChsrmzs7OlqKhIRC78/+Kp56dtbstMlkpKSmTr1q3VHvPpp58WANXWkCeyX8xrOQB59tlnPZpbpObXxJycHImIiJBnnnlGqfXiLPeYMWMkJCTEaps35FapPy9mrVjyZH+6MnOV+tPozFXsT1tabpPJJHfffbfVx1TqT1dyq9Sf9owZM0YAWOVWsT9tOZu5PZ7qT3vszdySKv1py9nMVepPexzN3F5/iqiT/WLX+eHDh2uVWaT+cqvUn/bYWysq9ueKFSsEgKxbt05ELsz8qaeeEgCya9cufV+V+tM2t2V229z2+lPL7onnp9GZO+pQ7d+4adMmJXM74qn+dGWtaFTpT1dmrlJ/ujJz1frTXnYRMbzOx48fLyaTqU76U9lLIbnC3nWu7Dl69CjGjRunn+bUrl07LFmypMbPi42NRbt27aptHzJkCADgjz/+sPt5586ds3u6imbixInw9/fHkCFDUFlZ6fAolydyl5aWOn1sy5mXlJRgzZo1AIDw8HCPZ3c288OHD2PPnj3Vjpj7+/vrl9LwVG5HM9+2bRvKy8tx7Ngxq3U+cuRIAMCePXus9ndH9o0bN2LPnj2YNm0agoKCnJ7iuHTpUphMJjRt2tRqe3R0ND744ANlcz/22GNITU2t8et7IndRUZHdd0/6+/ujZ8+e1V4Ttcc8efKkx7M7m7mz13LL01FVmrll9hYtWqB169a4/fbbHe6n2sy3bNmCoqIiVFRUID8/32tyq9SfF7NWVOlPV2auUn8anbmK/emIiOC2226z2qZSf7qSW6X+tEd7B6hlbhX70xF7M1epP+2xN3PL7Kr0pyP2Zq5Sf9rjaOYvvfQSYmNj8eCDDzrtT09mB4yt85KSEgBAUlISGjdurGxulfrTHntrRcX+1J5nCQkJVvs2bNgQAKxmqVJ/OsqtscydkJCA++67T5nfbRmdub+/PxYtWuQwt+VjqpQbUKs/XVkrWnZV+tOVmavUn67MXLX+dGXmtrSfQa+66iqr/rxYyl4Kqa7l5OSge/fuMJlMmDRpEuLi4vDFF19g/PjxyM/Px+TJk11+TO06WpaXrNE8/fTTeOSRR/S/b9y40eoUk/z8fJw6dQphYWF44oknMG/ePBQWFgIAfv/9d4/nNplMdj9uz/r16+1eg061mQNAgwYNkJGRgXnz5mHgwIEoLi4GUPXESk9P92huRzPXvmnWTkvVBAcHA6i6rprGXdm/+uorAEBAQAC6dOmCnTt3Aqj6ZnP+/Pn6dSyPHj2K4uJiREVFVXvcRo0a4eeff1Yyt1GezK2d1pabm1tjbu0xtTXj6eyA85mfPn0aFRUVVqd09u3b1+O5nc381KlTKCwsxNy5cx2e6qvqzEUE4eHhKCoq0p+rlgc6VcutWn/W5vnp6f50Za2o1J9GZ65ifzrSpEkT9OrVS/+7av1pNLdRnsyt/RLNSG5P9qcjzmauQn/a42zmKvWnI45mrkp/2mNv5vn5+di+fTtat26N48ePIyIiAoWFhfo1xS2pOnNL69evBwBceumlSudWqT/tsbdWVOzPXr16wcfHB+np6XjxxRf17/1mzZqFm266CW3atAGgXn/a5m7cuDEyMzMBwCq3K1SbeU20x1Q5twr96epaUak/XZ25Kv1pdOYq9qe97Lt37zb0/NR+BrX3ho+LUutzHtykpks5JCUlWW2Dzeko48ePl4YNG8qpU6es9hs5cqRERETop5wZVVJSIm3btpXk5GQpKyvTt2dmZkr//v1lwYIF8umnn8oVV1whAMTHx8fqFJVdu3bp2xMSEmT+/Pn6qSwA5IsvvvBo7rlz50poaKjdU2tErGc+bNgwCQgIUH7mIiIjRoyQwMBAfc7an3Hjxnk8t6OZ79y5UwBIx44drdb5l19+qZ9G6+7sgwYNEgASExMjt912mwwYMEAAiJ+fn/Ts2VM/1fff//63AJDY2FirxwUgPXv2FABSXFysXG4R6zXu6FIOnsq9evVq6dKliz5Hy9y22UVE+vXrJwDkscce83h2IzPXXk+0PwMGDPB4bmczr6yslNjYWP2UTu0yZ6qsF2czb9++vYSHh8uqVatk5cqV+unwTZo00R9Ttdyq9Wdtnp+e7k9X1opK/Wl05ir2p61Ro0YJAHn00UettqvWn0Zzi6jVn7b27Nmj57FHpf60ZWTmKvSnLWczV60/bTmbuUr9acvRzLX+DAgIEB8fH70/u3XrJgDktttu0/dVcea2z89hw4Z5xfNTpf605WitqNqfb775pkRGRlrNccyYMVb7qdif9nIDsPv/jbbOnV0KydPZbWdumdsSAPH395czZ84on1uV/jS6VlTsT6MzV60/jcxc1f40OnNb2s+g2nOztv4nDixUVlZKZGSk3HPPPXLy5EmrP0uXLhUAsmXLFpfy3H333QJAPv/8c0O5ExISpHXr1vr277//Xv8//qeffrLKHRQUJJdffrlHc4tcuO6zZW6NNvO8vDwJDAyUIUOGKD9zEZFbb71VwsLCZMyYMfLhhx/KkiVLBICEhITI/v37lZ35ZZddJn5+fhITEyOHDh2S9evXS1JSkgBV1/IUce/Mr776aqvC1Wb+7LPPCnDhOoraOo+Li7P6fADSq1cvASC5ubnK5Rap+Rcjnpy3bSbb61ZaZp81a5ZS2Y3M/JtvvpH169fLiy++KACkb9++Hs9tmd0295IlS8TX11caN24sIva/sVN95pa07CtXrlQyt2r9ebHPTxX605W1olJ/ujJz1frTVqdOnQSA/Prrr1bbVetPo7lF1OpPW48//riexx6V+tOWkZmr0J+2nM1ctf60ZXSdazzVn7YczdyyPxs0aKBvLygoEKDqlzoi3jFzrUO9Ya2o1J+2nD0/VezPL774Qvr37y9z586V6667ToCqN0M89NBD+j4q9qdl7rVr10qHDh0EgFVuTU0HFlScuWVujdah119/vVfkVqU/ja4VFfvzYteKiGf708jMVe1P2+xTpkyxO3NLlj+D1pX/iQMLOTk5+iJw9Mf2BhzOPPfccwJAZsyYYTj31KlTBbhwYyntSLqfn1+13GlpaWI2m+Xo0aMey22Z3TK3Rpu59o3R6tWrlZ+5iEhiYqIEBQVZ7Q9AAgMD5ZZbbvFobsvstrmPHDki8fHx+sd8fX3lkUceEaDqqKmIe2d+ww03CABZtmyZVe7MzEwBIE8//bSIGHvHSFZWlnK5RWr+xYgn522byTK3Zfb3339fTCaTfsBKhexGZ67R1vu8efOUnHleXp4kJCRIhw4d9Oz2vrHztpkDkPHjxyuZW7X+vNjnpwr96cpaUak/XZm5av1pqbKyUsLCwgSo/v2tav1pNLeIWv1pmzspKUmio6NrzK5Cf9pmNzpzjbbe3d2ftrkdzVzF/rTNfjEz90R/2uZ2NHPtdSU0NNRudh8fHykrK/OKmWsd6g1rRaX+tM3t7DVRtf7csmWL+Pr6yr///W8RudAv06dPF5PJJL///ruIqNeftrkts1vm1tR0YEHFmVvmFhG9Q70tt8ZT/Wl0rajYn3Uxc0/0p9GZq9if9rKLiN2ZW7L8GbSu/E/cY6GyshIAcPvtt2PMmDF297G8NqMzb7/9Nh577DHce++9ePLJJw1naNKkCYCqa/82btwYiYmJAKBfE9hSSEgIysrK9OuSeTK3Rstta8WKFYiIiMCNN95otV3FmR88eBDHjh1DTExMtX2bNm2KrVu3KpFbYznzRo0a4brrrsNXX32FlStXIiUlBQ0aNMDzzz+v/3vcmV1bv7Y3iomPjwcAnDlzBsCFG8fYu6F2QUEBoqOjYTablctthArz1tjLXVxcjDvuuAM33HAD3njjDbz11ltKZXdl5g0bNsSKFSswfPhwj+fWaLlfeOEFlJaWolmzZtixYwcyMjJw5MgRfb+zZ8+itLTU62YeHByM3NxcJXOr1p8X8/wE1OhPozNXrT9dmblq/Wlp69atKCgosPsx1frTaG4jPDnvzMxMdO/eHT/99JPD/VTpT9vsFzNzT/SnJWczV7E/bbNfzMw90Z+WnM1ce+0MDAy0+7nazSi9YeZah+bl5VnlVy23av1pm9vZa6Jq/blw4UIkJCSgS5cuVtsHDRqE6dOn48cff0Tbtm2V609HuQFARPTcRqk4c0ubNm3SO3TdunVek9uWJ/rT6FpRsT/rYuae6E+jM1exPy925o5+Bq2N/4kDC3FxcQgLC0NFRQX69et30Y/zySef4K677sLQoUPx+uuvu/S5Bw8e1LMAVd/YBQYGoqysrNq+BQUFCAwMRHJyssdza7TclioqKrB582aMHTsWAQEB1fb3dHbbmefk5ACoeoGwVVlZifLyciVya+zN3M/PD1deeSUAYO/evQCA5s2b6/u7K3vnzp2xePFiHD161Gr7sWPHrLI3atQIAQEB+g3ALB09ehRpaWlK5jZChdyWWSydPHkSJ06cQI8ePfDBBx9Uu/GaCtldmXlZWRny8vKUyK3RcmdlZeHMmTP45JNPAKDaDZxeeeUVjB07FpdcconHs7sy86KiIsTFxSkxc9vcqvWnq89PQJ3+NDpz1frzYmauSn9aWrFihcOPqdafRnMb4cncJpMJrVq1cnhgQaX+tM1+MTzRn5aczVzF/rTNfjE80Z+WnM08MTERDRo0QH5+PkJCQqp9rq+vL8LCwhAaGqr0zI8fP6536JIlS/TtKj4/VetP29w1vSYC6vRnTk6O3YMF2veD5eXlANTrT0e5NVpuo1TIbjtzTUlJCYYMGYIuXbrggw8+0G/2rXpuezzRn0bXior9WRcz90R/Gp25iv15MTO37E/bn0Frpc7Ofahntb1589ixY8Xf319+++23ap9/4sSJGr/+d999J4GBgdKnTx8pLi52uJ/tY2m5o6Ki5NJLL7X6WGpqqgCQjRs3WuX29/fXr0Xnqdwiot9ExTa39rGoqCgBIF9//bWeXeWZnzhxQvDfUzctb0gJVN2ASrtWs8oz19Z5RUWFfimIyZMn6/u4K/vx48clICBArrjiCqmoqNBnrl2nc/v27fq+rVq1EpPJJFlZWfo2/Pc0sAULFiibu6ZLOXgyt20my9x79+6VgIAAMZvNkpubq29XJbujmZeVlcmoUaPsvpabTCYZPXq0R3OL2J/5zp07Ze3atdKnTx+Ji4uTtWvXysKFC/X9RowYIWfPnvVodkczP3/+vNx6660OT0XVTtNULbeIWv3pyvNTRK3+NDpz1frzYmauSn9qSktLJSYmRho2bOjw+1uV+tOV3Cr1p23uK6+80uHPFKr1p212RzNXrT9tczuauYr9aZvd0cxV60/b3M7WeXp6ugBV96LTnDx5UgBIy5Yt9W2qzVzkwmvLSy+9pHeo6s9P1frTNreztSKiVn9OmjRJAMjmzZtF5EK/TJ48WQDr+26p1J+2uS2z2+YWMXbzZhVnftNNN4mPj4+0a9dO71DVc6vWn0bXior9aXTmqvWnK89P1frTXnYRsfv81Fj2Z10yidg5fK6gSZMm4fXXX7d7tH/s2LH49ttvkZGRoW8zmUyYNm0apk+fDqDqaM5ll12GkydP4u6770bbtm2Rm5uLXbt24auvvkJubq7Dr52ZmYkOHTqgtLQUL7zwAsLDw60+fumll+qns9x5553466+/0LdvXyQmJmLhwoXYuXMn/P39sWHDBvTu3Vv/vBEjRmDNmjUIDg7GlClTEBERgSlTpsDPzw87duxAhw4dPJY7IyMDL774IkpKSrB582ar3NrMV65cidjYWBw+fBg+Pj5eMfNWrVph//796NOnD4YOHYqCggI88cQTMJlM+Pbbb9GrVy8lZ56eno4vv/wSp06dwrRp0/Dee+9h+/btEBGPzBwAZsyYgaeeegrXXHMNSkpK8P3338NkMmHkyJF477339P1uvvlmfPTRR0hOTkZ6ejoKCwvxxBNPID4+HllZWQgICFAy9/Dhw/H111/joYcewrp16/Cvf/0LANCnTx/ceeedGD16tMdy33TTTXj99dexd+9ejBo1Ss9dUFCAdu3a4fDhw4iMjMS8efP0zx89ejTGjRunX9JBtZmfPXsWcXFxCAwMxNNPP42QkBD89ttveP311xEYGIjdu3cjJSVFuZlrLHsoIyNDf+eIys/PjIwMtGrVCoGBgZg5cyYAYMOGDVi/fj1atGiBffv2wcfHR7ncgFr9aZvbyFpRpT9dmblK/enKzFXsTwBYt24dBg4ciKuuugrfffed3e9vVetPo7lV60/L3G+88YbeLZbZVe1PIzNXsT+NzFyjWn8ambmK/Wl05jk5OUhOTkZxcTGeeuopRERE4I033sC+ffvwt7/9DW+88YaSMwcurJXY2FgcP34chw8fhq+vr9JrBVCvPy1zO1srqvXnf/7zH3Tu3Bkmkwn3338/fvzxR3z33XcAgGuuuQYbN27UP0+l/rTNnZSUhBdffBH79++vljszMxNDhgzBoUOH0Lp1a/zrX//CjBkz8I9//AM33XQT1q5dq+TMCwoK0KBBAxQVFWHOnDlo1KgRgKr+HDJkCB555BH06NFDudyq9acrawVQqz+Nzly1/nRl5qr1p73s3333HVauXGl3vQBAly5d9P60d1nhi1anhynqUW3PWBCpunnJxIkTpUmTJmI2m6VBgwbSt29fWbRokdOvvXnzZv2Ilb0/ll/nvffek169eklcXJz4+flJYGCgAJCdO3fazd2oUSMZMmSIhIeHS1BQkACQu+66y+O5Y2NjpXnz5g5nftNNNwkAmTJlir7NG2Y+evRoiY6OlrS0NAkNDZXQ0FABIHfccYfHczub+dKlSyUqKkpMJpOEhYVJ37595ZtvvvHYzEWqbvg1b948adWqlfj4+AgAefLJJ6W0tNRqvzFjxkhiYqL0799fgoODJTIyUgBUu1O9armvvfZah4951VVXeTS32WzW165lbsubNtn706FDB2VnXlJSIqmpqWI2myU8PFzMZrMkJSUJAElPT/d4bkcz11j2kL2bZ6k48zNnzkjz5s3Fz89PgoODJSAgQNq1a6fvq2pubd6q9Kdt7prWikr9aZvd2cxV6k/b3M5mrmJ/ioiMHDlSzGazfnNge1TrT6O5VetPy9ynT5+2+zOFqv1pmd3RzFXsT8vcjmauUa0/LbM7mrmK/WmZu6aZDx06VIKDg/X+vPrqq5WfuciF10TLDvWG3Kr1p2VuZ2tFxf78888/Zfjw4dKkSRP9e5aHH35Yzp07Z7Wfav1pmdtsNus3+7bN7exxbX/fpdLMa+rQMWPGKJlbxf40ulZE1OtPIzNXsT9dmblq/WmbPSkpye5roravZX/WJa85Y4GIiIiIiIiIiIiIiDyvDs99ICIiIiIiIiIiIiKi/+94YIGIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLDeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyzM/TAVRjMpkcfkxE3JjENd6aG/De7N6aG/De7Mztft6a3VtzA96bnbndz1uze2tuwHuzM7f7eWt2b80NeG92k8mExgC+BdDCYvtfAFoontsRlecNeG92b80NeG92b80NeG925nY/b83urbkB785ui2csEBEREREREXnIEQCjbbbZ/p2IiIhINTywQEREREREROQhjQEst9lm+3ciIiIi1fDAAhEREREREZEHWF4G6S8APf/7vy2cfA4RERGRCnhggYiIiIiIiMgDvsWFgwq9AWz77//+5bFERERERMbw5s1EREREREREHnDiv//bG1X3WsB//7c3gMMeyENERERklEm87XbTRERERERERP8f5OUBBQVA48aeTkJERETkEh5YICIiIiIiIiIiIiIiw3iPBSIiIiIiIiIiIiIiMowHFoiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsN4YIGIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLDeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDPt/cWBh7NixaNasmdU2k8mE6dOneySPUd6aG/De7N6aG/De7Mztft6a3VtzA96bnbndz1uze2tuwHuze2tuwHuzM7f7eWt2b80NeG925nY/b83urbkB783O3O7nrdm9NTfg3dnrk7IHFkwmk6E/3377bb1nKSoqwuuvv47+/fujYcOGCAsLQ8eOHbFgwQJUVFTUKndRURG6d++OyMhIxMTEAAD27dvn9tyuZv/jjz9w9OhRBAQEoFGjRpgyZUqdZL6Y7K7OvKysDAMGDEBoaCiio6MBAOfOnXN7bleyL1iwAD/99BOOHz8Os9kMk8lUJ3kvNrvR3N988w0OHDiAEydOoEmTJggJCUH79u0BAOXl5crm/vbbb7Fv3z5kZ2cjISEBAQEBSE5OBgCcPXvW7bldza4pKytD27Zt63y91NfMt2zZgszMTKvtAPDaa6+5Pber2UUEBQUFSEtLQ1BQkP56np2d7fbsruRetmyZ3Zk//fTTuOaaa5TNrT02+9O+2bNno3v37oiLi0NgYCBSUlIwefJknDx58qJzA/Xbn67kdiW7O/rTlewq9acruV3J/vDDD+PLL7/E4cOH9f6888476yyzq9kvpj+BCx0KAD/++KPSueu7P13J7Wr2+u5PV7Kr1J+u5HY1e0ZGBo4fP67351VXXVUneS8mu6vPz4KCAqSmpuodCgClpaXK566oqMAtt9yCyMhIhIeHAwDOnDnj9tyuZH/nnXewfft2ZGdnIzAwECaTCRkZGXWW2dXsrsw8MzMTJ0+eRPPmzREcHIzWrVsDAIqLi92e25XsM2bMwKZNm3DkyBEEBASgcePGGD58eJ1ldjX7xfYnAP11cP369Urn/uWXX+y+ls+cOdPtuV3NDlR9H96jRw+EhIQgMjISAHDo0CG3Z3cl9+rVqx32Z0pKiltzu5r92LFjyM7ORmxsLCIjI9GtW7c6yXux2WfNmoVBgwYhISEBJpPzAxzvv/8+OnXqhMDAQMTFxWH8+PE4depUnWT2q5NHqQfLly+3+vs777yDTZs2VduempqKxYsXo7Kyst6yHDx4EPfffz/69u2LKVOmIDw8HBs2bMCECRPw008/YdmyZfq+ixcvxtSpU1FSUoJ+/fph37592Lt3L3x9fdGoUSPMmDEDPj4+SE1NRVpaGpYtW4Zu3bphzpw5KC4uxoMPPoiVK1di+PDhGDp0qNtyFxYWIiYmRs8dExODjRs34vDhw2jatKmeGwBWr16N7du3Y8iQIejfvz/27t2LefPm1SprbbLPnTsXTz75JHx8fHDttddi9+7d+M9//gMfHx88/vjjaNOmDYCqtTJt2jSsW7cOBw4cwOzZs1FYWIi///3vWL58OWbNmgV/f3+35T58+DBCQ0P13AEBAfj444/1TFpuAPjll1/w119/4ZJLLsG5c+fq7JdnF5vd6MybNWuGrVu3olu3bhg0aBDi4+Oxbds2/P7773j33XcxY8YMvUhUyp2amopLLrkELVq0QFpaGqKionDo0CHMnDkTixYtwqOPPorExES35XZlrVi+Js6bNw9ZWVm1ylnb7K7MvGfPnjh8+DDeeust/fNHjx5dZz+g1+fMRQR5eXm46aabMGnSJJw7dw6TJ0+us1+61tfMly5dChGB2WzWP3/06NEAgP79+yubW6X+dGWtuKM/AWDnzp1IS0vDyJEjERYWhj/++AOLFy/G559/jl9++QUhISEAqr7XWrVqFdatW4fevXsjJycHf/zxBwBgwoQJ6NGjBwD39KcruQHgxhtv1HM3b94cn376KU6dOmWVG3BPf7qS3ejM3dGfruQGjM/8q6++Qv/+/dGuXTvExcXh0KFDWLx4MYCqXwrWlfpY55Y/U9RXh9ZH7vruT1dyA8bXijv605Xsrsy8vvvTldyA8Zlv3boV3333HQYMGIDBgwejuLgYb7/9NgDo/1Z3Zndl5rGxscjNzcXVV1+N9PR0vUNXrVqF2bNnuz336NGjERERgaZNm+K3337Tt1tKTU3Fyy+/jK5du+K7777DE088AbPZjClTpmDp0qV46qmn9INp7sitsczdvHlzHDx4sFr206dP488//0Rqair8/f3xyy+/1DpnbbK7MvPdu3cjOTkZQ4cO1ffdt28f3nzzTUybNg1BQUFuy60xMvPdu3fj8ssvR4cOHdCgQQNkZ2djyZIlAOr2YGt9zNyyPz/66CNs27atzvLWZ+6BAwfi119/xYIFCxAaGgqg6rV88ODBbs+tMbJWUlNT0aRJE5w6dQp9+vTB2LFjUVZWhvvvvx/5+fluz+7KzN9++20UFBQo05+AsZlnZWVh06ZN6N69O2677TaYTCZ88MEHAFCn692V7E8++SQaNGiAjh07YsOGDQ4fc8GCBZgwYQL69u2Ll156CUeOHMErr7yCHTt24F//+hcCAwNrF1q8xMSJE8WVuABk2rRpdfK1T548KXv27Km2/c477xQAsn//fn3bihUrBICsW7dORC7kfuqppwSA7Nq1S983JSVFunbtKpWVlVa5zWazDBo0yKO5LbNb5j527Jj4+fnJ6NGjrR5z3rx5AkBGjhxZ69yuZp8wYYL4+fnJn3/+aZW7SZMm0qlTJ6vPv++++yQoKEgyMzP1bdq/ceHChR7NLSLyt7/9TQBUy52dnS1FRUVW/z4tuyfWudGZl5SUyNatW6s9pjbzTZs2KZnbES33s88+69HcIo7XiiYnJ0ciIiLkmWee0XOrvFZERMaMGSMhISFW21TJLeJ45qtWrRIA8tFHHymZ/WLX+eHDh5XNrVJ/Gl0r7upPR1avXi0AZOXKlfq2I0eOiNlslokTJ4rIhZlfeeWV0rhxYykvL9f3re/+rE1ukar/HwBUy+2O/qxNdkczd0d/1ia3iOOZ27Njxw4BIH379q233CK1X+ca2w695pprlM5d3/1Zm9wijteKO/qzNtmNrBVLddmftckt4njm9vozLy9PAEirVq3qLbfR7I5m7qhDtZl/+umnbs0tInLo0CERqfqeQcthzz//+U8BINu3b7fKbTKZ5PHHH/d47q5du9rNfvr0acnPzxcRkeeff14AyKFDhzz2/LSX3dHMN2/eXG2btv/ixYvrOq6utjO3Jzs7WwBI586d6zquldrOXHP+/Hlp1qyZ3p9du3atr8giUvvc06ZNEwBy8uRJfZtKa9zRWtm2bZuYTCZ56aWXrLarlN3V398CsPu9b12p7cyvueYaSUxMlOLiYn1bWVmZAJD4+Ph6y+1Kdnv/35eUlEhkZKT06tXLqvs/++wzASCvvvpqrfMpeykkV9i7zpU9R48exbhx4/RLm7Rr104/AuxMbGws2rVrV237kCFDAFi/u0M7OpiQkGC1b8OGDQHA6uj44cOHsWfPnmrvOPP397faz5O5NVqebdu2oby8HMeOHbOa+ciRIwEAe/bssfo8d2T/4Ycf0LFjR/0UR82gQYOwa9cu7N+/X9+2dOlSmEwmNG3a1Grf6Oho/WijJ3P7+VWdRGSbOyEhAffdd58y69zozP39/bFo0SKHuS0fU6XcgPPXFcvLIam2VrTsLVq0QOvWrXH77bc7zKDazLds2YKioiJUVFQ4faeFajN/6aWXEBsbiwcffBCVlZVO32Wp2sxt13lJSQkAICkpCY0bN1Y2t0r9aXStuKs/HdG+puXr1yeffIKysjJMmDDBat/77rsPR44csXr3TX33Z21za2vBNrc7+rO22YHqM3dHf9Y2t6OZA9VfW7T/tr0MhUozt8w9depUpx2qWu767s/a5na0VtzRn7XNDjhfK5q67s/a5nY08/z8fBw/fly/xCcA/dI8lu8e9WR2oPrMtQ519I7M999/3625LbfX5LnnnoO/vz+6du1qtT05Odnt/elK7ujoaNx///3K9Kfl9pq8/fbbyvSn5XYjbF9b4uPjAXimPy2310TL/dxzz6GyshIPP/yw3f1Uy/3xxx8DAEQE+fn5EBG7+6mWe+7cuQgMDMQrr7wCEUFhYaHDfVXL7uj3LJGRkejZs6f+d9Vy5+fno6ioyO7PfJ7oT6PZ9+zZg7Nnz2LEiBFWPzvfeOONCA0NterPi6XspZDqWk5ODrp37w6TyYRJkyYhLi4OX3zxBcaPH4/8/HxMnjzZ5cfUTkeLjY3Vt/Xq1Qs+Pj5IT0/Hiy++qD/BZ82ahZtuusnqkggNGjRARkYG5s2bh4EDB+plUVJSgvT0dI/mbty4MTIzMwHAKrf2TbP2BNIEBwcDAI4fP65vc1f2kpISREVFVdtXy7Rz506kpKTg6NGjKC4utrtvo0aN8PPPPyuRW6PldoWns9vOvCbaY6qc+/Tp06ioqLC6HELfvn2VyK2xzX3q1CkUFhZi7ty5Di+V4ensjmYuIggPD0dRUZH+eZbXzvV0bo2WOz8/H9u3b0fr1q1x/PhxREREoLCw0OoHdlWyG3l+atdBvfTSS5XOrVJ/Gl0r7u5PEcHp06dRXl6O/fv3Y+rUqfD19UXv3r31fX7++WeEhIQgNTXV6nO164X+/PPPuOKKK9zan7XJbfnxK664osavZcnT2W1nXpO67M/6mnllZSVOnDiBrKwsPPPMMwBg9dro6eyOZl5aWoply5Zhy5YtdjtU1dzu6M+6XCvu7s/6fn7WV3/W9fOzd+/e+OCDDxAVFYWMjAwUFxfrl+S77LLLlMluO3OtQx19X7tz50635jaqsrISZ86cqXbZDaCqP3/44QcUFBTo941SJbcrVJt5TdzdnxejsrISJ0+eRHZ2NubOnQvAM/3pqoqKCsyZMwdLliyxe7kpVXMDQPPmzVFYWKg/Vy1/Ua9i7q+//hqxsbHIz89HXFwcTp8+jQYNGlTbT8XstrSfIy655BKlc/fu3Rv/+te/ICI4cOAATCYT3nvvPQDA5Zdfrmx2rT/tPSeDgoLw888/o7KyUr/0/UWp9TkPbuLsUkhjxoyRpKQkq22wOQ1k/Pjx0rBhQzl16pTVfiNHjpSIiAj9NHmjSkpKpG3btpKcnCxlZWVWH3vzzTclMjJSP50HgIwZM6bafiNGjJDAwECr/QDIuHHjlMkNwGq/nTt3CgDp2LGj1cy//PJL/TIU7s4+cOBAiYyM1E/V1NZKjx49BIC88MILIiLy73//WwBIbGys1eMCkJ49ewoAKS4u9lhuy+yWuTXaOnd2KQfVZm6Z2xIA8ff3lzNnziifOyAgwOr5MGDAAH0fFddKZWWlxMbG6pdE0E5Z9oa10r59ewkPD5dVq1bJypUrZcyYMQJUXQpHe0zVZr5r1y4BIAEBAeLj4yPz58+XFStWSLdu3QSA3Hbbbfrnqzhz2+fnsGHDBIA89thjSudWqT+NrhV39+fx48etZtO4cWNZtWqV1T433HCDNG/evFruc+fOCQCZOnWqiLi3Py8mt2V2y9wad/VnXc7cMrel+ujP+pq55WPGxMR4zcz9/f1l1KhRInKhQy0vhaRibnf1Z12uFXf3Z30/P+urP+v6+ZmTkyMNGza0eszY2Fjln59ah0ZGRlp9vvbYoaGhbs1tydllP7SP2ct9/fXXCwD5888/PZrb2WV5tHXu7FJIqs3cMrcloOryU/v27fN47ppm7ufnZ7W2gapLa2tUnXlwcLD07NlT36b9W1XO3bVrVwkLC5MVK1bI6tWrJT09XQBIdHS05OXleTy3vbWSm5ur96fJZJLnn39eVq1aJQMGDBAAcsMNN+j7qjhz2+fnQw89JABkwoQJSuR29PwsLCyUZs2aWT1mcHCwUq+J9i6FdPLkSTGZTDJ+/Hir7X/++af++LZZXfX/4lJINRERrFmzBgMHDoSI4NSpU/qfa6+9Fnl5edi1a5dLjzlp0iTs3bsXr732WrV3HzZq1AjdunXD3Llzcd111wEAVqxYgalTp1rt5+vrC7PZjDFjxuDDDz/UT41ZtWoVDhw44NHca9euRYcOHQDAKnenTp1w2WWX4bfffkNhYSEyMjLwxRdf4G9/+xsAoLy8HIB7Z37ffffpp/b8/PPP+ulBO3bsAACcP3/e6n/tvdNFe7yioiKP5d63bx9++OEH/eNaXqNUnLk92s3V+vXrh8jISOVzf/HFF1i/fj1efPFFAEBZWRkAz87b2Vp5++23cebMGafvoFZ15p07d0ZUVBRuueUWjBw5Ur+Z4OHDh7F69WolZ669m6WkpATx8fG47777cOutt+Lrr78GAHz//fcA1J25pfz8fHz++ecAoN/ASdXcKvWn0bXi7v6Mjo7Gpk2b8Nlnn+GZZ55BbGxstdOkz58/j4CAgGqfq/3/74n+rE1uy4+7QsWZ21Nf/VlfM09ISND70/YSWipktzfzAwcOoKysDP/85z/tfj1Vc7urP+tyrbi7P+vz+Vmf/VnXz8/g4GCEh4cjJCRE70/tkr25ubnKZLedeadOnRAbG4u8vDwsXbpU71AA8PHxwfnz592a2yjV+rOuqThze7R3Fffo0QMpKSnK546NjcWXX36J+fPn62fzaDdGVjV7dnY2ioqK9DMsbKmau23btoiOjsatt96KYcOG6flzc3Mxf/58JXNb9mdMTAwefvhh3HLLLXoPeaI/L1ZlZaV+KZ64uDilcwcEBCA8PBzBwcFYuXIl3n33XXTp0gVA1WUHVc0eGxuLW265BcuWLcOLL76IgwcP4ocffsCIESP0Szi5+rNTNbU6LOFGtTljIScnx+poj70/tjcNc+a5554TADJjxoxqH9uyZYv4+vrKv//9b6vc06dPF5PJJL///ru+b2JiogQFBVXLHRgYKLfccotHc1tmt8195MgRiY+P1zP4+vrKI488oh81FXHvzEWqbn4ZEhJi9fja57z88ssiYuwdl1lZWR7NHRERof+3lltT0zsuVZy5ZW4Rkffff19MJpPX5dZo633evHkez21vreTl5UlCQoJ06NBBz27vjAVPZ3d15gBk/PjxHs9tb+ba60poaKjd7D4+PlJWVubx7EZmvmTJEq9ZKyr1p73cjl7LPdGfmq1btwoA+eyzz/RtdXnGQl33pyu5LbNb5ta4uz9dyW70HdHu6E9XcltmdzZzzYEDBwSAXHfddR7P7mjmeXl5EhgYKBEREfq+tmcsqJhbxP396Upuy+z2Xlfc3Z+uZDc6c3f0pyu5LbPb5h4wYIA0btzYauanT58WANK2bVuPZ3c285tvvtnqTGJfX18BIImJiRIREeHW3JZqe8aC9vieyl2bMxZUnLllbhGR77//Xj/L9R//+IcSuY3MXKO9O71Hjx5KZLeXu6ysTCIjI/Uz5jXav1XV3CKO+zMkJET69u3r8dz21or2MZPJ5LD7MzMzPZ7dyMy/+eYbj/anvdyOnp9/+9vfJCoqymrmpaWleg+pkN3RjbvPnj0rgwYNsspx++23y9ChQwWAfib0xfqfuMeCdnT39ttvx5gxY+zuY3k9TGfefvttPPbYY7j33nvx5JNPVvv4woULkZCQoB+50gwaNAjTp0/Hjz/+iLZt2+LgwYM4duwYYmJiqj1G06ZNsXXrViVyA4CI6LmBqjMbrrvuOnz11VdYuXIlUlJS0KBBAzz//PP6v8ed2YGqd5Leeeed2L17N15++WV8+OGHiIiIAAC0atUKwIUbaFdUVFT7/IKCAkRHR+tH7DyR29/fH0uWLMH8+fOtchul4swtbdq0CXfccQduuOEGrFu3zmty22rYsCFWrFiB4cOHeyy3o7XywgsvoLS0FM2aNcOOHTuQkZGhHz0Hqm72U1pa6nUzDw4ORm5urkdzO5p5YmIigAvvrLOl3YzSG2a+YsUKREREIC8vzyq/arlV60/b3M5ey93dn5Z69uypv37deOONAKpezzZv3gwRsXo3pXa/B219u7s/Lza3RsttlIozt+SO/rzY3JqaZt6iRQsAwO7du5XJbjvzF154AZWVlQgJCUFGRgaAC+9AO3/+PDIyMvTrz6qU25n66M+Lza3RcnuiPy82e00zr+/+vNjcGi33wYMH8eWXX6JHjx44duyY/vHo6GgAVWe4qJLd3syDg4PRoEEDbNq0CdnZ2UhJSUHDhg2Rn5+P1NRUt+Y2Kjo6Gj4+Pg77E7hwc16Vchul4swt/frrrxg0aBDat2+PHTt26K/hque2pJ2F7on+NOqdd95BXl4eEhIS9P7UlJSUICMjQ8nczkRERLi9P42Kjo522J2aM2fOICEhAYBa2W2tWLECPj4++pwBNdd4aWkp3nrrLaSmpiI/P1/frv38c+zYsTr/PUtdZQeq1vMnn3yCrKwsZGRkICkpCUlJSejZsyfi4uIQGRnp8mNa+p84sBAXF4ewsDBUVFSgX79+F/04n3zyCe666y4MHToUr7/+ut19cnJy7H7joF0+RbvUQU5ODgDYvet8ZWUlysvLlcit0XJb8vPzw5VXXgkA2Lt3L4Cqm94A7p25JiQkBD169MCKFSsAAF999RWCgoL0G6k0atQIAQEB+s1LLB09ehRpaWkezQ0AS5cuBQCr3EapOHNNSUkJhgwZgi5duuCDDz7Qb1aqem57ysrKkJeXp+RaycrKwpkzZ/DJJ58AQLUbIL7yyisYO3YsLrnkEq+aeVFREeLi4pSceWJiIho0aID8/Hy7N+bz9fVFWFgYQkNDlZ758ePHsXnzZowdO1a/rBCg5vNTtf60zQ3U/Frujv60p7i42OoXX2lpaXjzzTfxxx9/6G8eAIB//etf+scB9/ZnbXJbftwVKmS3nbnGHf1Zm9yWHzdCW0MqZLedeVZWFkpLS3Hs2LFq/bllyxYkJydjx44dyuV2pq77sza5LT8OuL8/a5Pd2czruz9rk9vy44Dz/gQu/DJHhezOZp6SkoKUlBT974WFhejXr59bcxvl4+ODqKgo/SCCpaNHj6J58+ZITk5WLrdRKs5cU15ejgEDBiA+Ph7r16/XD+AAaud2xBP9aVRWVhZEBNnZ2dX6c/fu3UhOTsbq1auVy+3M2bNn0b59eyXn7ePjg7S0NP110h53d//FKCkpwZo1a9C7d2988803+nYVc2s3UnbUn0DVG7BUzG6padOm+uVJz549i507d2LYsGG1zvY/cY8FX19fDBs2DGvWrMGePXuqffzkyZM1Psb333+PkSNHolevXvpRNXtatWqFnJwcfPvtt1bbV65cCQDo2LEjAKBly5YAgHPnzlVbnJmZmejYsaMSuTVabnsqKyvx6KOPAoB+xoM7szvy0UcfYfz48fq7XQEgKSkJ58+f19+Ro8nNzcXNN9/s8dzau3Nscxvh6eyA/Znn5eXhxIkTaNasGdatW1ftbvQq5i4vL0dpaandfU+cOIEuXbp4PLe9tfLAAw9g7dq16NOnD+Li4rB27VosXLhQ/5wRI0YgOTnZ49mB6jMvLi7WD8DaM2DAAI/ndvT8HDFiBIqKilBcXKxvO3XqFICqgzs+Pj4ezw7Yf35q3n//fVRWVuK2226z2q5ibtX60x6jr+X10Z/nzp1DUVFRte1r1qzBmTNnrM5MHDx4MMxms352heaNN95Ao0aN0LNnT31bffdnbXNra8E2txGezg7Yn3l992d9zLy8vBxnzpyp9pjbt28HcOHdx57ODlSf+QMPPGDVn5Yd2qFDB6xduxYtW7ZULrc7+rO+np/u6M/6en5q6qs/62PmLVu2hI+PDw4dOmT1mNqZOQ0aNFAiO+B85hrtQIifnx/uvfdet+Z2RVJSEkpLS/V7RmkOHTrk9v6sa6pmP3/+PHJycuDj44MNGzbo125XPfeJEyeqbdPOAPBEfxo1cuTIav25du1aAFWvO2vXrkXPnj2Vyw3Aqn8sFRUVub0/XTFixAiIiNV197V/S2xsLBITE5XNrlm/fj3Onj3r0f40Kj4+HpGRkcjKyrLars0/JiYGQUFBSmZ35PHHH0d5eTkefPDBWj/W/8QZCwAwZ84cbN68GZdddhnuvvtutG3bFrm5udi1axe++uor/WZV9mRmZmLQoEEwmUwYPnw4PvzwQ6uPX3rppfrpLJMmTcLSpUsxcOBA3H///fpimjt3Lq655hpcdtllAKqOwqWkpGD//v3o27cvhg4dqr+Toby8HI8//rhHcyclJWHjxo0AYJUbANLT07Ft2zYUFBTg1VdfxXvvvaf/wGj5CxR3Zc/MzMQtt9yCQYMGoUGDBtiyZYu+j3ajQ8vPO3DgAPr06YP09HT9hSA+Ph533nmnR3P//vvv+jvNbXNnZmZi9+7dyMvL078pnTlzJoCqUzxVnXlBQQE2btyIyspKjB49Wr+hEFD17oVt27ahR48eyuUuLCzEhx9+iMDAQLz00ksICQnBb7/9BqDqpj3/+Mc/PDpvR2ulU6dO6NSpEz7++GMcPHgQN910k9XpqG3atNGfo6rNPDs7W5/5q6++CgDYsGEDgKpLaAwePFjJmQNVpbxo0SKcOHEC06dPR0REBN544w0AQN++ffX9VJu5pRUrViAxMRG9e/eu9jHVcqvWn66sFXf05/79+9GvXz+MGDECbdq0gY+PD3bs2IF3330XzZo1Q3p6ur5v48aNMXnyZDz//PMoKyvD/v37AQA//PADVqxYAV9fX6t/c332Z21yd+3aVe+X5557ziq3O/qzPmbujv6sj5kXFhaiSZMm+uVJFi5ciN9++00/i6dXr17KzrxTp05o2rSp3p/AhV/oxMfH69tUy+2O/qyv56c7+rO+XhM19dWf9THzuLg4jBs3Dm+++SYCAwPx2muvoaCgQP+lvnYmnaoz3759O06fPo0FCxagrKxMvyHvjTfeqL8D0125AWD58uXIzMy0+iWQ1i+jR49GUlISgKrvv3fv3o0bbrgBDz/8sH7pjJCQEDz00EMez61dFmvmzJlWufPy8vT+1G6q/tprr+n/X2hUnPmmTZtQXl6O22+/HVu2bNG/p9y9ezc2bdqEa665RsmZX3LJJQgJCUF+fj4WL16M/fv346233gIAq3c/qzbzNm3aVOtPTVRUlNv702huAFi9erX+M39gYKC+VhISEvC3v/3N47kdrZW//e1vePrpp3H69Gk88sgjaNq0KZYvXw4A6N+/v/54Ks5cs2LFCgQEBGDYsGEYP3681cdUm7mvry8efvhhPPnkkyguLsbcuXNRUVGhPz898f2tvezff/+93ZnPmTMHe/bswWWXXQY/Pz98/PHH2LhxI2bOnImuXbs6zGNYre7Q4Ea1uXmzJicnRyZOnChNmjQRs9ksDRo0kL59+8qiRYucfu3Nmzc7vfmG7df5888/Zfjw4dKkSRPx8fERAPLwww/LuXPnrPYbPXq0REdHS1pamoSGhkpoaKgAkDvuuMPjuc1ms4SFhQmAarmXLl0qUVFRYjKZJCwsTPr27avfdMUTM8/NzZXBgwdLgwYNxN/fX8+dn59f7XHHjBkjiYmJ0r9/fwkODpbIyEgBIA899JDHcycnJ0unTp3srnNnj2u79lWaueWNg+39GTNmjJK5S0pKJDU1Vcxms4SHh4vZbJakpCQBIOnp6R6ft7O1ImL9mmjv5s0qzvzMmTPSvHlz8fPzk+DgYAkICJB27doJAHnyySc9nrummQ8dOlSCg4MlPDxcgoKC5Oqrr1Z+5iIXXhMByJQpU0TEc/3pSm6V+tOVteKO/jx58qTcc8890qZNGwkJCRF/f39JSUmRyZMny8mTJ6vtX1FRIbNnz5akpCT9e5Z333232n713Z+1ye3v7y/R0dEe68/6mLk7+rM+Zl5SUiLp6en6Otf6c/z48V6zzi3Xhe3Nm1XM7Y7+rK/np0j992d9vybWV3/W18zLysqkW7duYjab9f7s06ePMtmdzfzyyy8Xs9ksISEheod6MvdVV13l8DV68+bN+n5jxoyRxo0by/DhwyU8PFz/nuX+++9XOrezHrK8yb2K2Z3151VXXaVs7mnTpklMTIz4+PiIn5+fJCYmysiRI71mndv7nZx282ZVc6ekpOi/+zKbzdKyZUsBrG8cr2JuEZERI0ZISEiIREdHS0BAgFx22WVes1aaNm0qgYGBMnToUBHxbH+6MvMrr7xS/P39JTIyUoKCgrxm5uvWrZNu3bpJWFiYBAcHS/fu3eWDDz5wmsUVJhEnF4kiIiIiIiIiIiIiIiKy8D9xjwUiIiIiIiIiIiIiIqobPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhvl5OoBqTCaTw4+JiBuTuMZbcwPem91bcwPem5253c9bs3trbsB7szO3+3lrdm/NDXhvduZ2P2/N7q25Ae/Nztzu563ZvTU34L3ZvTU34L3Zmdv9vDW7t+YGgL9MJvQGcMRiW2MA3wJooXh2WzxjgYiIiIiIiIiIqAaNAIR7OgQRebUWqDqI0Pi/f9cPKngoT23wwAIREREREREREZGFxnb+/h2ALz2QhYj+//gLFw4uTOrUCT+azWjx3+3ehgcWiIiIiIiIiIiILHwL++8ojvdQHiL6/6E3LhxcmLdrF5qUleGv/273NjywQEREREREREREZEF7R3EPXDio4K2//CMidRwBMNpm22hY33PBW/DAAhERERERERERkQXtHcU/wvqggjf+8o+I1NEYwHKbbctR/fJr3sAkqt8qm4iIiIiIiIiIyJ1+/BG4/PILf9+6FejZ03N5iOj/hxYtgIMHgebNgeXLgdGjL/z9L++60wIPLBARERERERERERERkWG8FBIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhvHAAhERERERERERERERGcYDC0REREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIb9vziwMHbsWDRr1sxqm8lkwvTp0z2SxyhvzQ14b3ZvzQ14b3bmdj9vze6tuQHvzc7c7uet2b01N+C92Znb/bw1u7fmBrw3O3O7n7dm99bcgPdm99bcgPdmZ27389bs3pob8O7s9UnZAwsmk8nQn2+//dYteWbPno3u3bsjLi4OgYGBSElJweTJk3Hy5Mla5a6oqMAtt9yCyMhIhIeHAwDOnDnj9tx//vmn4ezvvPMOtm/fjuzsbAQGBsJkMiEjI6POMrua3ZWZZ2Zm4uTJk2jevDmCg4PRunVrAEBxcbHbc7sy8xkzZmDTpk04cuQIAgIC0LhxYwwfPrzOMruavTbPz2uuuQYAsH79eqVz//LLL8jMzLTaDgAzZ850e25X1oo283PnzqFHjx4ICQlBZGQkAODQoUNuz+5K7tWrV9ud+dNPP42UlBS35nZ15seOHUN2djZiY2MRGRmJbt261Unei8l+MWulU6dOCAwMRFxcHACgqKhI+dyq9OexY8fYn27O7crM2Z/uz61Sf7qyVtifdZPb1ZmzP92fu6ysDAMGDEBoaCiio6P1f4u7c7uSfcGCBfjpp59w/PhxmM1mfY3Xtbqe+TfffIMDBw7gxIkTaNKkCUJCQtC+fXsAQHl5udtzu5L94YcfxpdffonDhw8jICAAycnJuPPOO+sss6vZL7Y/y8rK0LZtWwDAjz/+6PbcrmQfMGAAli1bZvf1vC7V58wXLFiAtLQ0BAUFAQCWLVuGX3/9Vdncjub99NNP6993uSu3q9kzMjJw/PhxREZGIiYmBldddVWd5L2Y7K6ulYKCAqSmpiIgIACNGjUCAJSWlro9d0ZGhkvZ8/LykJOTo/fn6NGj6yxzXWZ///33rfbdvn07JkyYgM6dO9dLh/rV6aPVoeXLl1v9/Z133sGmTZuqbU9NTcXixYtRWVlZr3l27tyJtLQ0jBw5EmFhYfjjjz+wePFifP755/jll18QEhICALjuuuvw3XffoWvXrmjevDm2bNmC/fv3w2Qy4dFHH9W/kUhNTcXLL7+Mrl274rvvvsMTTzwBs9mMKVOmYOnSpXjqqacQExPjttxvvvkmgoOD9dznz5/HJ598gvPnz+Oxxx7TcwPA6dOn8eeffyI1NRX+/v745Zdfap2zNtldmfnu3buRnJyMoUOHomnTpvjtt9+wb98+vPnmm5g2bZpegO7I7crMd+/ejcsvvxwdOnRAgwYNkJ2djSVLlgAAsrOza53Z1eyuzNzy+fnRRx9h27ZtdZa3PnMPHDgQv/76KxYsWIDQ0FAAwOjRozF48GC353ZlraSmpqJJkyY4deoU+vTpg7Fjx6KsrAz3338/8vPz3Z7dlZm//fbbKCgogNls1r+OVtb9+/d3a25XZp6VlYVNmzahe/fuuO2222AymfDBBx8AQJ2u9/qYeZcuXbBs2TJ06NABL730Eo4cOYJnn30Wy5YtwzPPPIPAwEC35Z41axaWL1+OVq1aISYmBtu2bcOff/4JABg4cCBuueUWPbdK/Xnq1Cm0adNGz11RUYEvvvgCJ0+etMoNqNefrsxcpf50Zeaq9acrM1epP13JrVJ/urJWVOtPV2auUn+6MnPV+tOVmavUn5Y/HxcXF2PSpEkoKSlBQEAA3nzzTf1jqampmDZtGtatW4cDBw5g9uzZKCwsxN///ncsX74cs2bNgr+/v9tyW2YvLi7GI488gvz8fFRWVlb7mf+XX37BX3/9hUsuuQTnzp3Dvn37ap2zNtmNzrxZs2bYunUrunXrhkGDBiE+Ph7btm3D77//jnfffRczZsyok1/w1MfMv/rqK/Tv3x/t2rVDXFwcDh06hMWLFwOo+qVgXamPdW7Zn/PmzUNWVlad5XU1t2X2mmb+2Wefwd/fH2+88Ybd13N3Z3d15uPGjcMDDzyAO+64A5MmTcLdd9+NiIgInDhxQtncS5cuhYgo0Z+W2WtaK1u3bsV3332HAQMGYPDgwSguLsbbb78NAPjjjz/qJLcr2V2ZeWxsLHJzc3H11VcjPT0de/fuxbx587Bq1SrMnj3brbk13bt3R1paGgBgy5Yt2LNnD15++WXExsbq+0REROCHH35AYmIi0tPTUVhYiBdeeAFA1Rve6oqr2UeNGoXrr7/ealuPHj2s/r5+/Xq8+eabuPTSS9G8efO671DxEhMnThRX4gKQadOm1V8gEVm9erUAkJUrV+rbduzYIQUFBfrftdxxcXFy+eWXW33+P//5TwEg27dvt8ptMpnk8ccf92huEZHx48cLgGq5T58+Lfn5+SIi8vzzzwsAOXTokFfMfPPmzdUeE4AAkMWLF3s0t4jjmduTnZ0tAKRz5851ntdSbWeuOX/+vDRr1kyeeeYZASBdu3ZVOve0adMEgJw8eVLfpsoaF3G8VrZt2yYmk0leeuklq+2qZDeyVixpz8+tW7fWS2aR2s/8mmuukcTERCkuLta3lZWVCQCJj4+vt9xGszuaeUlJiURGRkqvXr2ksrJS367N/NVXX3Vrblta7htvvFFCQkKkvLxc/5hK/eksu21u1frTUW57M1epP+1xNHN7PNmftpzNXKNCf9pyllul/rTH0VpRrT9tGVkrljzVn/Y4mrlq/ekot+3MVe7Pxx57TCIjI/V527rvvvskKChIMjMzq+VeuHChR3O3bt1aWrVqZfdn/uzsbCkqKhIR698LqPD8dDbzkpISu89BbeabNm2ql8witZ+5PTt27BAA0rdv37qMWk1t17kmJydHIiIi9P685ppr6iuyiNR+5mPGjLH771F9nYuIrFq1SgDIRx99pG/zhtz2aM/Pw4cP12VUK7VdKykpKdK1a1erDsrLyxMA0qpVq3rLLVK7mR87dkz8/Pxk9OjRVtu1mX/66aduza39HPb888/r2xz97tlef27atEn/PqE+Gc3uiKMOrSvKXgrJFfauc2XP0aNHMW7cOCQkJCAgIADt2rXT37V2MbSvefbsWX1b586d9XdnWbryyiurHTl87rnn4O/vj65du1ptT05O1t+t48nc2jttbHNHR0fj/vvv98qZv/322w5zW+6r2syB6us8Pj4eQPXLUKg2cy33c889h8rKSjz88MN2v45quT/++GMAgIggPz8fIqJUbkdrZe7cuQgMDMQrr7wCEUFhYaHDr6XazB29lkdGRqJnz54ez+1o5vn5+SgqKtIvDQMAfn5VJwRavvvFk9mB6jPfs2cPzp49iz179lR7t5zZbLY6hdIduZ3tW1RUZHV6rEr96YxtbtX609m+ttlV6k9nbHMDavWns31ts6vUn67kVqk/nbHNrVp/OtvX0Vqx5Yn+dMY2t2r96Wxfy+yq9uf+/fvx8ssv44orrnD4+UuXLoXJZELTpk2ttkdHR3usP7XcL730ksN37yckJOC+++5Trj9rmrm/vz8WLVqkXH8amTlQ/bVF+29P9qeRda7lnjp1Klq3bo3bb7/d7n4qzrykpATNmjWr8Uw51WY+ceJE+Pv7Y8iQIaisrHR4eTXVctuu8ZKSEgBAUlISGjdu7NHcztZKfn4+jh8/juTkZH2bdmlYT/ZnTTPftm0bysvLsWHDBrsf9+TPn+fOnXN6OaY1a9YgPj4evXr10rf169cPAPD7779b7ata9oSEhDo5u9wRZS+FVNdycnLQvXt3mEwmTJo0CXFxcfjiiy8wfvx45OfnY/LkyTU+hojg9OnTKC8vx/79+zF16lT4+vqid+/eNX6udu1QTWVlJc6cOVPtNBYAaNSoEX744QcUFBSgqKjIo7kBWOV2hWozr4m2r6dzW2axVVlZiZMnTyI7Oxtz584FAKsy8XR2RzOvqKjAnDlzsGTJErsvaKrmBoDmzZujsLBQf65a/qLB07mB6mvl66+/RmxsLPLz8xEXF4fTp0+jQYMG1T7P09mNPD9//vlnAMAll1yiTG6g+sx79+6Nf/3rXxARHDhwACaTCe+99x4A4PLLL1cmu+3MtW+c7X3Dajab8fPPP+uvOe7Mff78eZw7d07/gWrp0qXo0aOH/tqhan9quQsLC/VLZ1jmdoW710pNM6+Jp/rTlZmr1p9GZ65af7qyVlTqTyNrRdX+vJjnpwr9aWTmqvZnTTNXtT8nT56MPn36ICkpye5jHT16FMXFxYiKiqr2sUaNGunrxt3z1nJff/31mDJlSo2P7YynsjuaeU081Z+uzLyyshInTpxAVlYWnnnmGQCe7U+jMy8tLcWyZcuwZcsWu89VVWdeXl6OrKwsREREICoqCqNGjVImu6OZ5+fn49SpUwgLC8MTTzyBefPm6Z1v+QtX1XLbo93H6tJLL/V4bmdrpXfv3vjggw8QFRWFjIwMFBcXY968eQCAyy67zOPZHc3cWX8CVZcB8kTup59+Go888ghMJpPd31EcPXoUJ06cQOfOnXHq1KlqHz9+/Lj+357M3rlzZ8yaNavOLuNlWJ2e/1CPnJ2uMWbMGElKSrLaBpvTrsaPHy8NGzaUU6dOWe03cuRIiYiI0E8Lceb48eP6KToApHHjxrJq1SpDuU0mk/zjH//Qt588eVIASGRkZLXc119/vQCQP//802O5RUSGDBkiAKxya7SZO7uUg2ozt8xtSdt33759Hs0tUvPM/fz89McMDQ0VAPLUU0/p+6g68+DgYOnZs6e+DTaXclAxd9euXSUsLExWrFghq1evlvT0dAEg0dHRkpeX59HcIvbXSm5urgCQgIAAMZlM8vzzz8uqVatkwIABAkBuuOEGfV8VZ277/HzooYcEgEyYMMHjuUUcPz8LCwulWbNmVo8ZHBys/Gui1kOhoaFW+1s+/qlTp9ye+9lnn7Xat2/fvpKVlVUtt2r9aZsbgFVujYr9WdPMLXNb8nR/ujJz1frT6MxV608juVXsz5rWisr9eTHPTxX608jzU9X+NNpDKvXnunXrxM/PT37//XerS09Z+ve//y0AJDY2tlrunj17CgApLi72WG4RkdatWwvg/Gd+Z5dCUm3mlrktARB/f385c+aMR3OL1Dxzy8eMiYnxmpn7+/vLqFGjROTCJUMsL4Wk4synTp0q7du3l7i4OFm5cqXV/C2/h1dt5rt27RIA4uPjIwkJCTJ//nxZsWKF/thffPGFkrlFqj8/hw0bJgDkscce07epuFZycnKkYcOGVo8ZGxur/PNz586dAtj/Oc6yV92VOzMzU/r37y8LFiyQTz/9VObOnav/nLBu3Tp9P60/r7jiCruv51p/ejp706ZNxcfHxyq7LV4K6SKJCNasWYOBAwdCRHDq1Cn9z7XXXou8vDzs2rWrxseJjo7Gpk2b8Nlnn+GZZ55BbGys09Okgap3vABVR/UfffTRatvtHanTTgEuKiryWO4TJ05g48aNAGCV2ygVZ26P9q6oHj16ICUlxaO5jcw8NjYWX375JebPn4/U1FQA0G9MperMs7OzUVRUpL9D1Jaqudu2bYvo6GjceuutGDZsmJ4/NzcX8+fPV3KtaJ9XUlKCmJgYPPzww7jlllvw+eefAwC+//57AOrO3FJlZaV+KmRcXJzHczt7fgYEBCA8PBzBwcFYuXIl3n33XXTp0gUAcOTIEY9ndzTz2NhYNGvWDIWFhXjxxRdx8OBB/PDDDwAAH5+qbw880UOjRo3Cpk2bcM0111T7N1j+t2r9qeV+7733kJKSUi23UZ5YKzXN3B4V+tOVmavWn0ZmrmJ/GsmtYn/WtFZU7k9Xn5+q9KeR56eq/VnTzFXrz9LSUjz44IO499570bZtW4ePpVp/Gs1tlDvXSm2yazcn7devHyIjI5XPnZCQgPXr1+PFF1+sdgktVbMfOHAAZWVl+Oc//2n346rmfvbZZ9G5c2cEBwdj5MiRePvttzFr1iwAwN69e5XNrn1eZWUlPvnkE9x333249dZbAQBBQUGYOXOmkrlt5efn672vXQJX1dzBwcEIDw9HSEgIPvzwQyxZsgQNGzYEUPX9lqrZO3XqhNjYWOTl5WHp0qXIyMjAF198AaCqP8+fP+/W3E2bNsWGDRtw7733YuDAgUhPT8eIESMAAA899JC+n9afvr6+Dr+eCtl//vlnxMXFWWV3izo6QFHvanPGQk5OTrV3zNj+sbzJjFFbt24VAPLZZ5/Z/XhhYaHEx8cLAPntt9+sPmbkHZfa43sid9euXcXf37/GmTt6x6WKM7fMLSLy/fffS2BgoNU7ADyZ2+jMNdq763r06OHx7I5mXlZWJpGRkdWOVAMX3nGpYm4Rx68rISEh0rdvXyXXiva6YjKZHB5Jz8zM9IqZf/PNN3oWFV5XnD0///a3v0lUVJTVzEtLSwWAJCYmejy7s5mPGjVKgoKCqmVp06aNAJB9+/Z5JLfIhd6/++67pUmTJvq7O1TuT9vslrk1qvanZW7bmVvmFlGrP22zO5u5RpX+tMxtO3OV+9NZbhF1+9M2u73XFVX70zJ3TTNXqT9ts9vmVrk/LXPbm7lK/TlnzhyJioqS06dPW+W+mDMWsrKyPJZbpHZnLLhzrRiduWVuEZH3339fTCaTMrlFjM1cc+DAAQEg1113ncezO5p5Xl6eBAYGSkREhL7N9owFb5p5UVGRAJCOHTt6PHtNry1+fn5W2wFIWlqamM1mOXr0qHK5RaznvWTJEo/2pytrZcCAAdK4cWOrtXL69GkBIG3btvV4dmczv/nmmyUgIEDP4OvrK0BV70dERCjzPQtw4QbeRs9Y8HR2kaoznyyzO/r31aX/iXssaO9Iu/322zFmzBi7+1heQ82onj17omHDhlixYgVuvPFGq4+VlpZi6NCh+vW32rdvb/Xx6Oho+Pj4oKKiotrjFhQUALhwc0FP5N69ezeuv/56/QZ8rlJx5pZ+/fVXDBo0CO3bt8eOHTv0dxd5MrerM9euj7p7926PZ3c083feeQd5eXlISEhARkaG1cdKSkqQkZGhZG5nIiIikJubq+RaiY6O1t9d4ciZM2eQkJDgsexGZ75ixQr4+PjocwbUfH6WlpbirbfeQmpqqtVN1rSbZh07dgylpaXKrnN/f3/Ex8fj+++/R0ZGBpKSkvR3YcbFxSEsLMztuW0NHz4cixcvxvfff49rr71W2f605/Dhw3puozyxVmzZztySSv1pj5GZq9Cftmxnrmp/1pTbGU/2pz2Wa0Xl/rRV08xV6U97LGeucn/asjdzVfozLy8PM2fOxIQJE5Cfn6//AQARQUZGBoKDgxEfH6+/m9VRf0ZHR+vz90RuACgrKwMAq9xGuWutuDJzS5s2bcIdd9yBG264AevWrVMiN+DazFu0aAHA/f3pysxfeOEFVFZWIiQkRO9P7Qyo8+fPIyMjQ//exRtmrt3bRXvHtIozT0xMBHDhjC1LISEhKCsr099trVJuWytWrEBERATy8vL0bSo+Pw8ePIgvv/wSPXr0wLFjx/THjI6OBlDVtZ7O7mzmwcHBaNCgATZt2oTs7GykpKSgYcOGyM/PR2pqqhK9r8nNzUXjxo31/nR0xmhgYCACAgKUyN6kSROr7O7wP3FgQfvmrqKiQr9rd10pLi62euEBqp7Ad9xxB77++mv0798fX375ZbXP8/HxQVRUlP5LEEtHjx5F8+bNkZyc7LHcH3zwAb755puLfnwVZ64pLy/HgAEDEB8fj/Xr11uViidzX+zMtRvgqDjzrKwsiAiys7OtbvIFVH1DmpycjNWrVyuX25mzZ8+iffv2Sq4VHx8fpKWl4V//+pfDx46Li1NyrVgqKSnBmjVr0Lt3b6t/p4oz126qJCIOH7uiokL5mTdt2tTq9PZjx45hxIgRbs9tj/YNnLaviv3pjCv7Au5f5/bYzlyjUn86Y3RfT/WnPbYzV7E/jeR2xlP96Yzl64qK/WmPs5mr0p/OaPuq2p/2OJu5p/vzzJkzKCwsxHPPPYfnnnvOar+ioiIkJydj8ODB+Pjjj9GoUSMEBATor32Wjh49irS0NCVyA7DKbZQK2W1nrikpKcGQIUPQpUsXfPDBBwgODlYqN+DazN3dn67MPCsrC6WlpTh27Fi1/tyyZQuSk5OxY8cOj+cGjM1c+35XWzMqzjwxMRGBgYH6L8Ft8wcGBrrte/OLeX4CVTff3bx5M8aOHYslS5bo21WYN2C9VnJycgDAYX9qv9xWIbuzmaekpOiXSgSqLqnVr18/JXpfo11SslGjRoiLi7N742YAaNCggb6/p7MfPHhQz+Iu/xP3WPD19cWwYcOwZs0a7Nmzp9rHT5486fTzz507h6Kiomrb16xZgzNnzujXAtXcf//9WLVqFebPn68f1bcnKSkJpaWl2LFjh9X2Q4cO4eabb/Zo7qFDhzp97JqoOvPz588jJycHPj4+2LBhQ7Unm6ozP3HiRLVt2jswtHcIqDjzkSNHok+fPoiLi8PatWv1PwDQsmVLrF27Fj179lQuN1D1wm1PUVERBgwYoOxaGTFiBETE6hp82r8lNjYWiYmJSq4VS+vXr8fZs2dx2223WW1Xcebx8fGIjIxEVlaW1XZt/jExMQgKClJ+5rYqKyvx4IMPujW3o8d66623YDKZ0KlTJ32bSv3p7LFscxuhQnZ7M1epP12ZuWr9aXTmqvWnK2tFpf50Za2o1p+uzFyjQn8anbmK/XkxM7fl7v6Mj4+3eo1Yu3YtrrvuOgBV76Bcu3YtHn/8cf3zk5KScP78ef0drZrc3Fy39qe93GvXrkWjRo0AoFpuI1SdeV5eHk6cOIFmzZph3bp1+jvQVcjtaObl5eU4c+ZMtcfcvn07APf3pyszf+CBB6r158KFCwEAHTp0wNq1a9GyZUvlZl5cXGz3TTMzZswAUNX9gJozB6p+8V1RUYFNmzZZPe6ff/6Jq6++GmazWcncmvfffx+VlZUe609X1krLli3h4+ODQ4cOWT2mdmaO9ktuVdeKLe1AiJ+fH+69916P9772fcill16qn6kAAMOGDcORI0eszvr7+uuvAQDt2rUD4Pnvt44ePYolS5ZUy17v6vTCSvWoNvdYEBHJzs6WpKQkCQ4OlvT0dFm4cKE8++yzcvPNN0tUVJTTr/3zzz9LTEyMTJgwQV599VV57bXXZOzYseLn5yfNmjWzutv3yy+/LEDVdXuXL18u/fr1EwCyfPlyWb58uRQWFur73nrrreLn5yfx8fHy3HPP6Z8bGhoqJ06c8Ghu2+yWuc+ePSsdO3aUyMhIGTBggACQhx56SGBxvUVVZx4VFSUA5NFHH9U/DkCGDBkiGzduVHbm8fHxkpycLFFRUbJo0SJ55JFHJDo6WgDIuHHjlJ65o+endo1oVXP7+vpKSEiIvPjii/L666/LqFGjBIAkJCTIuXPnPJrb2VopKiqSyMhIASAPP/ywvPrqq9K1a1cBILfeeqvSM9fWyrBhwyQgIEDOnj2rzGu5s5nPnDlTAIi/v7+8/PLL8sILL0hqaqr+2uLp7M5m3qlTJwkJCZFXX31V5s+fL/379xcA0qdPH7fnTk9Ply5dusiTTz4pixYtkh49eujXorz//vutHlel/rTNPWfOHP2+Fra5VetPV2auUn+6MnPV+tOVmavUn67kVqk/XVkrqvXnxawVFfrTlZmr1p+uzFyl/rTl7NrWw4cPFx8fH2nRooW8+uqrMnv2bAEg8fHxUlxc7NHcIo6vJ56RkaH352WXXSYAZMaMGQJAbrrpJn0/1Waen58vwcHBAkDmzJlTrT9//PFHj+YWsT/zM2fOSEhIiLRs2VKioqLkjTfekIkTJ+r/lkmTJun7qjZzker9aXuPBU/mFrE/80OHDklkZKS0bt1aoqOj5ZVXXtHvHQZAnnrqKY9ndzbzW265RXx9fSUsLEymTZsmL730kgBV91345ZdflM2trZXOnTtLYmKiVFRUeKw/7XH0mnjXXXcJAAkMDJR58+bJ7NmzpXHjxgJAxo4d6/HszmaempoqoaGhMn/+fHnllVf013RPvJaPHTtWrrzySpk+fbosWrRInnjiCf3+D5s3b7Z63KysLAkICBA/Pz+9P7Wfj/7+978rkT0mJkb8/f2rZc/IyJAZM2bIjBkzrDp0xowZ8s477zjNZMT/zIEFkaqbl0ycOFGaNGkiZrNZGjRoIH379pVFixY5/donT56Ue+65R9q0aSMhISHi7+8vKSkpMnnyZDl58mS1LNqLv70/hw4dstq3cePGMnz4cAkPD5fQ0FC737iqllsrZnt/LG+SpGJ2Z/tdddVVyuaeNm2axMTEiI+Pj/j5+UliYqKMHDnSa9Z5Tb8YUTF3SkqKmM1mCQsLE7PZLC1bthQAMnXqVKVzi4iMGDFCQkJCJDo6WgICAvTy8Ia10rRpUwkMDJShQ4eKiHe8louIXHnlleLv7y+RkZESFBTkNTPv27ev+Pv7S1hYmAQHB0v37t09lnvjxo1y4403SmJiopjNZjGbzQJAli5dKpWVldX+jar0p23usLAwadCggQCollu1/nRl5ir1pyszV60/XV3nqvSnK7lV6k9X1oqIWv3p6lpRpT9dnblK/enKzFXqT1s1/RItMTFR+vfvL8HBwfrBtIceesjjuUUc/xJt8+bNDjvI9nVSpZk7630AMmbMGI/mFrE/85KSEklPT5eoqCgxmUxiNpslKSlJxo8f7zXrvKYDC57KLeL4YM7tt98uYWFhYjKZJCAgQNq1a6cf/POGmTdq1EiGDBki4eHh+s3t77rrLuVzJyYmCgCZMmWKiHiuP+1x9JpYVlYm3bp1E7PZLKGhoRIaGip9+vRRJruzmV9++eViNpslJCREwsLCpG/fvh7L/d5770mvXr0kLi5O/Pz8JDY2Vpo3b2535iIigwcPlsDAQL0/b7vtNqWyDxkyRHbu3FntcZ11qOXPcRfLJOLkwpZEREREREREREREREQW/ifusUBERERERERERERERHWDBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLDeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw/w8HUA1JpPJ4cdExI1JXOOtuQHvze6tuQHvzc7c7uet2b01N+C92Znb/bw1u7fmBrw3O3O7n7dm99bcgPdmZ27389bshwMCMKK0FMsBtADwF4DeAI5A7dwA8JfJpGdtDOBbXPg3tFA4u7euFcB7szO3+3lrdm/NDXh3dls8Y4GIiIiIiIiISGFNSkvxI6ofVPAGLVB1MKEHrA8q9PZYIiIiqgs8Y4GIiIiIiIiIyEuMhvccVAD+e2YCgB8t/t4b3vVvICKi6njGAhERERERERGRl1iOqksKeYt7g4Ot/u5tB0aIiMg+HlggIiIiIiIiIlLYXwB64sK7/7+F9xxceKOoyOrv3nZghIiI7OOBBSIiIiIiIiIihfUGsO2//2t5cKGRxxIZp91TwVsPjBARkX0m8bbbTRMRERERERER/a86fBjo3RuIjwe+/BKIiPB0IudatAC+/RZo0uRC9oMHgebNgb/+8nQ6IiK6SDywQEREREREREREREREhvFSSEREREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhvHAAhERERERERERERERGfb/4sDC2LFj0axZM6ttJpMJ06dP90geo7w1N+C92b01N+C92Znb/bw1u7fmBrw3O3O7n7dm99bcgPdm99bcgPdmZ27389bszO1+3prdW3MD3pvdW3MD3pudud3PW7N7a27Au7PXJ2UPLJhMJkN/vv32W7fkmT17Nrp37464uDgEBgYiJSUFkydPxsmTJy8q9zfffIMDBw7gxIkTaNKkCUJCQtC+fXsAQHl5udtzZ2RkGM7+8MMP48svv8Thw4cREBCA5ORk3HnnnXWW2dXsF7tWysrK0LZtWwDAjz/+6Pbcrsx8wIABWLZsGTIzM62217X6nPmCBQuQlpaGoKAgAMCyZcvw66+/Kpvb0byffvppXHPNNW7N7cpa+fbbb5GRkYHjx48jMjISMTExuOqqq+ok78Vkd3WtFBQUIDU1FQEBAWjUqBEAoLS01O25Xc2el5eHnJwchIaGIjo6GqNHj66zzK5mdyX3qVOnkJubi86dO8NsNnvF64pq/elKdvZn3eR2JTv7s25yu5LdZDI5nPk777xTJ7ldye7qzIuKitC9e3e9QwFg3759yudWpT+nT5/O/lQ0t2r96cpaYX/WTW5XZs7+rJvcrsyc/emZ3Kr0p6vZ2Z+1z+1K9qlTp+Lrr7/GkSNH9P6cOXOmR7MfP34c99xzD5KTkxEUFIQWLVpgypQpOH36tNV+ixcvxlVXXYWEhASrDs3IyKiTzH518ij1YPny5VZ/f+edd7Bp06Zq21NTU7F48WJUVlbWa56dO3ciLS0NI0eORFhYGP744w8sXrwYn3/+OX755ReEhIQAAF566SVMmTIF3bt3R1paGrZs2YI9e/bg3nvvRevWrREbGwsAaNasGbZu3Ypu3bph0KBBiI+Px7Zt2/D777/j3XffxYwZM+rkCWY0t0bLDUDP/vLLL+u5AeCrr75C//790a5dO8TFxeHQoUNYvHgxgKoX5bpS1zO3XSvz5s1DVlZWneV1NbfGyMw/++wz+Pv744033oDZbNa313V51NfMx40bhwceeAB33HEHJk2ahLvvvhsRERE4ceKEsrmXLl0KEbE77/79+7s1t8bIWtm6dSu+++47DBgwAIMHD0ZxcTHefvttAMAff/xRJ7ldye7KzGNjY5Gbm4urr74a6enp2Lt3L+bNm4dVq1Zh9uzZbs0NADNnzsSsWbMQFRWFK6+8Er/99hv27t2LK6+8Evfcc4++X0REBH744QckJiYiPT0dhYWFeOGFFwAAFRUVdZLblezLly9HZmamnj0kJAT79+/H4MGDkZubq2dPTU1Fx44dsWHDBphMJjRv3rxOv/mvr9wq9qfRtaJaf7qyVlTrT6MzV60/XZ25Kv0JGJ95Xl4eQkJCrDp0x44deOWVV9CiRYs6ye1KdldmnpaWhmXLlqFbt26YM2cOiouL8eCDD2LlypUYPnw4hg4dqmRulfpz6NChyMnJsfpcrfuDg4Px+uuvw8+v6kdQ1fpz1qxZOHz4cLXc0dHRKC4u1rOr1p9Gc6vWn66sFdX605W1olJ/ujJz1frT1Zmr0p+uzFy1/nRl5ir1pyu5VerPwsJCxMTEoKSkBP369UNMTAw2btyIw4cPo2nTppgxYwZ8fKreG65afy5evBhTp07Vs+/btw979+6Fr68vGjVqpGdXrT+Nzry4uBh33303unXrhrvuuguJiYnYtm0bpk2bBgAQEY9k79GjB86dO4cJEyagSZMm+PXXX/Haa69h8+bN2Llzp75efv75ZyQnJ2PQoEGIiorSO3TdunX49ddfkZiYWLvQ4iUmTpworsQFINOmTau/QCKyevVqASArV67Utx06dEgAyPPPPy8ijnOXlJTI1q1bq20HIABk06ZNHs0t4trMd+zYIQCkb9++dZ7XUm1mbiknJ0ciIiLkmWeeEQByzTXXeDy3iOPsY8aMkZCQkGrbVV/nIiKrVq0SAPLRRx95VW57tOfn4cOH6zyvprZrJSUlRbp27SqVlZX6try8PAEgrVq1qrfcRrM7yn3s2DHx8/OT0aNHW23XZv7pp5+6NXdFRYW0b99eLrvsMikqKnKa/b777pOgoCDJzMzUt23atEkAyI033lhvuY1md7bOs7Ozq/37PPX8NJpbtf50Za3Y48n+dGWtaFToT1dmrlp/ujJzlfqztut8/PjxAkAefPDBesmsqe3M7XUoADGbzTJo0CAlc6vWn/aMGTNGAMjdd99ttV21/rSlzdxkMlXLrlJ/2nKUW7X+tMfRWrHHk/1py9la0ajQn/Y4mrlq/WnL2cxV6k97XFnnnuxPW85mrlJ/Gs2tWn+uWLFCAMi6deuqZQcgu3bt0rer1p+22bXcTz31VLXsKvWn0Zk76s+nn35aAFRbQ57KLiJ2Z26P1qHPPvtsrfMpeykkV9i7zpU9R48exbhx4/TTP9q1a4clS5Zc9NfVvubZs2ftfvzcuXMOjxb6+/tj0aJFDnNbvrPYE7lrOvXLdubafxcXF1vtp9LMLXNPnToVrVu3xu233253PxVnXlJSgmbNmiE/P9/pfqrNfOLEifD398eQIUNQWVmJc+fOeUVu2zVeUlICAEhKSkLjxo09mtvZWsnPz8fx48eRnJysbwsPDwcAq3cbeSq7o5lv27YN5eXl2LBhg92Pv//++27NvXHjRuzZswfTpk1DUFAQioqKHL4TYc2aNYiPj0evXr30bf369QMA/P7771b7eiK7s8sbPPbYY0hNTa3x66iUW7X+dGWtAGr1pytrRaX+dHXmKvWnKzNXqT9rs85LSkqwZs0aABf6yJPZnc388OHD2LNnT7V3bfv7++uX0lAtt2r9aY/2bsTbbrvNartq/emIiFTLrlJ/OmKbW7X+tMfRWgHU6k9H7K0VlfrTHmczV6k/HbE3c5X60x6j69zT/emIvZmr1J9Gc6vWn9rzLCEhwe7nWM5Rtf50lL1hw4bVsqvUn0Zn7u/vj549e1broSFDhgBAtcsUqTZzo495sZS9FFJdy8nJQffu3WEymTBp0iTExcXhiy++wPjx45Gfn4/JkyfX+BgigtOnT6O8vBz79+/H1KlT4evri969e1fb9+mnn8Yjjzyi/33jxo0uXT5FuzyIp3KbTCary6vYU1lZiRMnTiArKwvPPPMMAFj9MlPVmZeWlmLZsmXYsmWL3dN9VZ15eXk5srKyEBERgaioKIwaNUqZ7Brbmefn5+PUqVMICwvDE088gXnz5qGwsBCAdeGpltue9evXAwAuvfRSj+d2tlZ69+6NDz74AFFRUcjIyEBxcTHmzZsHALjssss8nl1jO3PtwI2jU/B37tzp1txfffUVACAgIABdunSxOpUwNzcX0dHRAKq+aThx4gQ6d+6MU6dOVftax48f1//bk9kBYOTIkZg/f76e3Shvy+3u/jS6Viyp0p+uzlyV/nR15ir1p9GZq9afF7PONevXr7f7Q4tqMweABg0aICMjA/PmzcPAgQP1X1iWlJQgPT1dydyq9ac92i/RLH8BomJ/OtKkSROr7EZ5W25P/fxpyd5asaRKfzriaOaq9Kc9zmauUn86Yjtz1frTnprWucbT/emIvXWuUn8aza1af/bq1Qs+Pj5IT0/Hiy++iMaNGyMzMxMAcNNNN6FNmzYA1OxP2+zac27WrFlW2Y1SbeaOZGdnAwCCg4OVyL57926nMz99+jQqKiqsOrRv37415jES2Cs4O215zJgxkpSUZLUNNqfSjB8/Xho2bCinTp2y2m/kyJESERGhn4rjzPHjx/VTYgBI48aNZdWqVVb7ZGZmSv/+/WXBggXy6aefyhVXXCEAxMfHp9opKo5y+/v7y5kzZzyae+7cuRIaGmr31Botu+VjxsTEeM3M/f39ZdSoUSJy4TItlqeiqjjzqVOnSvv27SUuLk5WrlxpNf9//OMfHs/uaOa7du3StyckJMj8+fP1U7YAyBdffKFkbpHqz89hw4YJAHnsscf0bSqulZycHGnYsKHVY8bGxir//Ny5c6cAkMjISKvP1x47NDTUrbkHDRqkv7bddtttsnr1aunSpYsAkJ49e+qn+f773/8WAHLFFVfYfT0HIMXFxR7NPmDAAAEgfn5+VtlFrNe5o1NRVc+t8VR/Gl0rltlV6U9XZ65Kf7oyc9X60+jMVevPi1nn2nN02LBhEhAQ4BXrfMSIERIYGGj1mABk3LhxyuZWrT9t7dmzR9/fkor9aWvUqFECQB599NFqH1OpPy82t8ZT/WnL0VqxzK5Kf9qqaeaq9KctZzNXrT9tOZq5av1py8g6V6U/bTlb5yr1p9HcKvbnm2++KZGRkdXmWFZWpu+jan/ayz5mzBir7CLq9aeRmdvLLiLSr18/ATzzOyJH2e3NXKO9nmgd+uqrr9aYxYj/F5dCqomIYM2aNRg4cCBEBKdOndL/XHvttcjLy8OuXbtqfJzo6Ghs2rQJn332GZ555hnExsbqR+I0TZs2xYYNG3Dvvfdi4MCB6NChAwAgLi4ODz30kNPH124O069fP0RGRno0d3p6OkaMGAEADnMnJCRg/fr1ePHFF9G0aVOrj6k68wMHDqCsrAz//Oc/7X49VWf+7LPPonPnzggODsbIkSPx9ttvY9asWQCAvXv3ejy7o5lrn1dZWYlPPvkE9913H2699VYAVadmzZw5U8nctvLz8/H5558DAAIDAwGou1aCg4MRHh6OkJAQfPjhh1iyZIl+Olxubq7HszuaeadOnRAbG4u8vDwsXboUGRkZ+OKLLwAAPj4+OH/+vFtza3/v2rUr3n33XQwbNkw/4+PHH3/E119/DQA4f/48AMDX19fh1/N0du1mbzNmzLDKboS35PZkfxpdK5ZU6U9XZq5Sf7oyc9X60+jMVevPi1nnwIX+vP766622qzhzoOq13Gw2Y8yYMXqHAsCqVatw4MABJXOr1p+2VqxYYXe7iv1p6z//+Q8A+5crqYm35PZkf9pytFYsqdKftpzNXKX+tOVs5qr1py1HM1etP20ZWeeAGv1py9k6V6k/jeZWsT8bNWqEbt26Ye7cuVi7dq3+s/PUqVP1fVTtT8vs1113HYCq9W6Z3QgVZ27P7Nmz9bNLPfE7InvZp0yZ4nTmX3zxhVWHOrpMnMtqf2zCPWpzxkJOTk61o0+2fyxv7GPU1q1bBYB89tlnNeaeOnWqANY3fbXM/f7774vJZFImt2V229y22UVEDhw4IADkuuuu83h2RzPPy8uTwMBAiYiI0Pe1fceIN828qKhIAEjHjh09nt3RzLWj6X5+flb7A5C0tDQxm81y9OhR5XKLWM97yZIl1Y6kq7pWBgwYII0bN7ZaK6dPnxYA0rZtW49ndzbzm2++2eoouq+vrwCQxMREiYiIcGvuG264QQDIsmXLqmUHIE8//bSIGH/HiCeza7kzMzOtsovU/I4Rb8jt6f40ulbsZRfxbH8anblq/VnbmXuyP43OXLX+vNiZa/2p3XROheeos9eWxMRECQoKsnpMABIYGCi33HKLsrlV6k9LlZWVkpSUJNHR0QJc3BkLnsweFhZWLbdGpf682Nye7k/b3I7Wir3sIur8/Ols5qr1p21uV2euys+fzmauWn/a5jY6cxX60za7s9cWlfrTldwq9eeWLVvE19dX/v3vf+vbLG88/fvvv4uImv1pm13LPX36dKvsImr1p9GZ22bX+lO7uboq2UXE7sztOXDggAQGBsq8efNczmPrf+IeC5WVlQCA22+/HWPGjLG7j+V1043q2bMnGjZsiBUrVuDGG290um+TJk0AVL1j2PLGrwCwadMm3HHHHbjhhhuwbt06pXJr7OW2pL2Lavfu3QDUyG478xdeeAGVlZUICQlBRkYGAODIkSMAqo7oZmRk6NcL9oaZazdj0Y5YqzjzxMREANDnaikkJARlZWX6kVeVcttasWIFIiIikJeXp29TYd4aLffBgwfx5ZdfokePHjh27Jj+ce06zIcPH1Ymu72ZBwcHo0GDBti0aROys7ORkpKChg0bIj8/H6mpqW7Nra1dRzdyOnPmDIALN0fSnoe2AgMDERAQoET2+Ph4q+xGqJ5bhf40ulYc8WR/Gp25av1Z25l7sj+Nzly1/rzYmWv9adsJKs784MGDOHbsGGJiYqo9btOmTbF161YlcwNq9aelrVu3IjMzE927d8dPP/1k9TEV+9M2e0FBgcuPq1E9twr9aZvb0VpxRJWfP53NXLX+tM3t6sxV+fnT2cxV60/b3EZnrkJ/2mZ3NHPV+tNobkCt/ly4cCESEhLQpUuXavuLCH788Ue0bdtWyf50lH3QoEGYPn26nt0IFXID1jO3VFxcrPfnG2+8gbfeekup7EZn3qJFC3Ts2BErVqzApEmTXM5k6X/iwEJcXBzCwsJQUVGh3ym9rhQXF1v9stGRgwcP6lkslZSUYMiQIejSpQs++OADq5t+qJDbMosR2g1wVMhuO/OsrCyUlpbi2LFjVjf5AoAtW7YgOTkZO3bs8HhuTU0z1wpSWzMqzjwxMRGBgYEoKyurtm9BQQECAwORnJysXG5Lx48fx+bNmzF27Fj9lE5tX0/ntswCVN0oCKgqQXu0olMhu7OZp6SkICUlRf97YWEh+vXr59bcnTt3xuLFi3H06FG7+2u5GzVqhLi4OLs3zgKqbmSm7e/p7NrBJqOv59q+quZWpT+NrpWaeKI/jc5ctf6s7cw92Z9GZ65af17MzCsqKvT+DAgIqLa/p7PbztxZh1ZWVqK8vFzJ3JZU6E9LK1asgMlkQqtWrar9Ek3F/rTNXhsq51alPy05Wys18fTPn85mrlp/2uZ2deaq/PzpbOaq9aclozNXpT9tszuiWn9aMvparkJ/5uTkoKKiwuH+5eXlANTsT0fZteehlt0IFXJrbHOfPHkSJ06cQI8ePfDBBx/Az8/6V+oqZHdl5ufPn9c7tDb+J+6x4Ovri2HDhmHNmjXYs2dPtY+fPHnS6eefO3cORUVF1bavWbMGZ86csTpC5OixlixZgksvvVQ/uggAeXl5OHHiBJo1a4Z169bp7wBQJbd2JN8yd3l5ud13pW3fvh3AhXcIeDo7UH3mDzzwAPr06YO4uDisXbsWa9euxcKFCwEAHTp0wNq1a9GyZUvlZl5cXGz3KPuMGTMAAC1btgSg5swBIDk5GRUVFdi0aZPVvn/++SeuvvpqmM1mJXNr3n//fVRWVla7JqOn521vrbRs2RI+Pj44dOiQ1b7aO6O0bzI8nR1wPnONdiDEz88P9957r1tzDx48GAEBAVi6dKmew9I111yj//ewYcNw5MgRq2LXrn3drl07AO6duaPsb775ZrXsNVE1t0r9aXStqNifRmeuWn8anbmK/enKOlepP115TbR8fHv9Cag5c209nDt3rtovRzIzM9GxY0clc9vjyf7UlJWV4cMPP8QVV1yBsLAwu4+rWn/aZnf2PUpNVM2tUn/a5na0VlTsT9vsjmauWn/a5nY0cxX70za7s3WuUn/a5nb2mmj5+Cr0p212RzNXrT+N5rbHk/3ZqlUr5OTk4Ntvv7X7WB07dtT/W7X+dJR95cqV1bLXRIXcGsvcf/zxB77++mv4+fnZ7U9VstvO3FmH/vbbb3afOy6r9cWU3KQ291gQEcnOzpakpCQJDg6W9PR0WbhwoTz77LNy8803S1RUlNOv/fPPP0tMTIxMmDBBXn31VXnttddk7Nix4ufnJ82aNbO62/fYsWPlyiuvlOnTp8uiRYukc+fOAkD8/f1l8+bN+n75+fkSHBwsAGTOnDmyfPlyWb58uQCQIUOGyI8//ujR3E888YR+rTnL3GfOnJGQkBBp2bKlREVFyRtvvCETJ07U/y2TJk1SduYi1deK7TUuVZz5oUOHJDIyUlq3bi3R0dHyyiuvyPXXX69fo+2pp57yeHZnM7/lllvE19dXwsLCZNq0afLSSy8J/nvdy19++UXZ3Npa6dy5syQmJkpFRYUyryuO1oqIyF133aVfz3LevHkye/Zsady4sQCQsWPHejy7s5mnpqZKaGiozJ8/X1555RW57LLLBIDcdNNNbs8tIvLMM8/orw+vv/66tG3bVgDIqFGjrPbLysqSgIAA8fPzk1dffVVmz54tUVFRAkD+/ve/ezx7r1699OtE2mYfNmyYREZGyowZM/R5A5A+ffrIO++8o2Ru1frTNrejtaJifxqduYha/Wl05ir2pyszV6k/jc5cM2bMGPH399f7U8Rz35u7MvOUlBT9NVDrUG3f7777TtncqvWniMhnn30mAPTXOns/x6nYn5bZr7rqKoc/f6rWn0Zyq9iflrkdrRVV+9PIzEXU60/L3I5mrmp/WmZ3NnPV+tPIzDWq9adldmczV60/jeZWqT///PNPCQkJkdDQUHn88cfljTfe0Odq+Xohol5/2mbXZm4vu0r9aXTm+fn50qRJEwEgkZGRen9qHTpu3DiPz/yNN96QUaNGVcuudei4cePkxRdftOrQ6Oho2bdvn9NMRvzPHFgQqbqRxsSJE6VJkyZiNpulQYMG0rdvX1m0aJHTr33y5Em55557pE2bNhISEiL+/v6SkpIikydPlpMnT1rt+95770mvXr0kLi5O/Pz8JDAwUADIzp07rfbTvqFw9GfMmDEezR0bGyvNmzevNvOSkhJJT0+XqKgoMZlMYjabJSkpqdpNS1ScuYixb+w8ldvRzM+cOSO33367hIWFiclkkoCAAGnXrp1e1t4w80aNGsmQIUMkPDxcgoKCBIDcddddyudOTEwUADJlyhQRUed1xdFaEREpKyuTbt26idlsltDQUAkNDZU+ffook93ZzC+//HIxm80SEhIiYWFh0rdvX4/lFqm62de8efOkVatW+jwBSGlpabV9Bw8eLIGBgRIcHCyRkZFy2223KZPdx8dHAMiTTz5ZLfu1117rsIeuuuoqJXOr1p+2uR2tFRX70+jMRdTqT9vcjmauYn/aZq9p5qr0p9GZa2666Sar/hTxXIfaZnc289GjR0t0dLSkpaXpHQpA7rjjDqVzq9afIiIjR44Us9ksp0+fdvpznGr9aZlde322R7X+NJJbxf60zO1orajan5bZna0V1frTMrejmavan5bZa5q5Sv1pmbum10TV+tMyu7OZq9afRnOr1p9//vmnDB8+XP862o2nz507V21f1frTMrv2PcvDDz9cLbtq/Wlk5jX1Z4cOHTw+c60bbWeudeill14q4eHhVh166NAhp3mMMok4uBg3ERERERERERERERGRjf+JeywQEREREREREREREVHd4IEFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDOOBBSIiIiIiIiIiIiIiMszP0wFUYzKZHH5MRNyYxDXemhvw3uzemhvw3uxNTCZ8C6CFxba/APQGcFjh3N46b8B7s3trbsB7szO3+3lrdi13Y6DaazoUzg14/8ztYe764a3ZvTU34L3Zmdv9vDW7t+YGvDe7t+YGvDc7c7uft2b31tyAd2e3xTMWiMhrHAEw2mbb6P9uJyIi73IEwB2eDkFEREREREQXhQcWiMhrNAaw3Gbb8v9uJyIi79IYwLs+/FaUiIiIiIjIG/GnOSLyGt+i6pIZfwHo+d//bfHf7URE5D20yyAlV1YiJzQUA6Oj8ZeHMxEREREREZFxPLBARF5DO6jQG8C2//6vdnCBiIi8QyNYHyjuUliIf/n64mon1xolIiIiIiIitfDAAhF5De2ggnZPhSO4cHCBiIi8QwGAE7jwml7eoAGWLFmC/IgIj+YiIiIiIiIi40zibbebrmfeemdub80NeG92b80NeG/2xiYTjtrZ3gjAEYVze+u8Ae/N7q25Ae/Nztzu563ZTSYTwgGEATgKwMfHB+Hh4cjLy0NlZaWH0znnzTN3hLnrh7dm99bcgPdmZ27389bs3pob8N7s3pob8N7szO1+3prdW3MD3p3dFg8sEBERERERERERERGRYbwUEhERERERERERERERGcYDC0REREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhv2/OLAwduxYNGvWzGqbyWTC9OnTPZLHKG/NDXhvdm/NDXhvduZ2P2/N7q25Ae/Nztzu563ZvTU34L3ZvTU34L3Zmdv9vDW7t+YGvDc7c7uft2b31tyA92Znbvfz1uzemhvw7uz1SdkDCyaTydCfb7/91i15Zs+eje7duyMuLg6BgYFISUnB5MmTcfLkyTrJXVZWhrZt2wIAfvzxR7fndiX7gAEDsGzZMmRmZlptr2v1OfMFCxYgLS0NQUFBAIBly5bh119/dWtuV7KbTCaHM3/nnXfqJLcr2V2deVFREbp3747IyEjExMQAAPbt26d87oKCAqSmpiIgIACNGjUCAJSWlro9t6vZ8/LykJOTg9DQUERHR2P06NF1ltnV7K7kPnXqFHJzc9G5c2eYzWaPvq64kn3q1Kn4+uuvceTIEYSEhKB9+/aYOXOmx7K7MvN9+/YhOzsbCQkJCAgIQHJyMgDg7NmzSue2xP68+OzsT/ZnffXQH3/8gaNHj+r9OWXKlDrLbM/Zs2cRHx8Pk8mE1atXX3RuACgpKcEVV1yB4OBgNGjQAEDddn995D527BhOnz6N9u3bw9fXt9oPve7M7Ur29PR0bNy4EYcPH0ZYWBg6duyIBQsWeCy7KzPfvXs3jh8/bvXcAYBz5865Pber2e09Zn2qq5l/+eWXdl/L3333XaVza2bPno02bdogMDAQALBixQocOXLErbldye6sPz/99NM6z11TdldmLiIoKChAWloaQkNDkZCQAAA4fPiw23O7kv2rr77CL7/8ovdn8+bN6+VnCqPZXV3nZWVlGDBggP4zKOCZ10RXcrvj50+juQsLCw1nd9fPn0azuzJzd/z8aTS3KzO3fD3Xfv709HqZNm0aBgwYgOjoaJhMJrz99tt2H2fs2LF2/01t2rSpk5x+dfIo9WD58uVWf3/nnXewadOmattTU1OxePFiVFZW1muenTt3Ii0tDSNHjkRYWBj++OMPLF68GJ9//jl++eUXhISEAAAWL16MqVOnoqSkBP369cO+ffuwd+9e+Pr6olGjRpgxYwZ8fHyq5Z43bx6ysrI8lruwsBAxMTF67piYGP0b/aZNm+q5AeCzzz6Dv78/3njjDZjNZv1r1fUvL+tr5uPGjcMDDzyAO+64A5MmTcLdd9+NiIgInDhxwq25XZl5Xl4eQkJCICL6zHfs2IFXXnkFLVq0qJPcrmR3ZeZpaWlYtmwZunXrhjlz5qC4uBgPPvggVq5cieHDh2Po0KFK5o6NjUVubi6uvvpqpKenY+/evZg3bx5WrVqF2bNn1zqzK7kPHz6M0NBQ+Pj44Nprr0VAQAA+/vhjFBYW4u9//7tVIUREROCHH35AYmIi0tPTUVhYiBdeeAEAUFFRUSe5Xck+d+5cPPnkk3r23bt34z//+Q98fHzw+OOP69lTU1PRsWNHbNiwASaTCc2bN6/TX565mtvozIuLi3H33XejW7duuOuuu5CYmIht27Zh2rRpAAARcXt2V2Z+ySWXoEWLFkhLS0NUVBQOHTqEmTNnYtGiRXj00UeRmJioZG6V+tOV56dq/enqzFXpT1dmrlp/ujJzlfrTlZmvXr0a27dv/z/27js8qjJ9H/g9JJNMElIhpNC7EBQQpaogRQEFpQorCAsqKAriWhBXRKp9RUQBCwKLIPWnKGXBBQtWFJUgLLgQSoBACCRASH9+f+R7jtNzBiZz3lnvz3Vx7XLmZHLz+M7cmZw5Z9CvXz/ccssten9WpilTpiA/P9/tbUuXLsW8efPw/fffo2fPnjh06BD27t2LKlWqYPLkyWjatCmA8pmPGzcOK1asQH5+Pl599VUcO3YMM2fOxMqVK/3W/ZWROzk5GcXFxYiNjfXL8/aV5AaA9u3b67mTkpKwdu1a5Obm4u9//7ue++jRo5g8eTK6du2Khx9+GAkJCdi8eTMefPBB07L7MvO6deuiTZs2SEtL0x87r7zyCt59911MnTpVf+wEIjdgbOZadq1DH3/8ca/3GYjsvsy8SZMmCA0NxfPPP69//fDhw9GpUyelc7/55pvo06cPZs6cifvuuw/XXHMNRo8ejbCwMOTm5qJWrVoByw0YWyuFhYUoKChw6c9NmzZh2bJlfu1Po9l9mXl8fDxycnLQu3dvPPjggzh37hyefPJJLFq0CGPGjEHbtm0Dlhsw/vicO3cufvnlF4wcORLt2rXDt99+i2eeecavWX3J/uqrr+LRRx9FtWrVkJiYiH379gFw/V1ds2bN8Oyzz+KTTz7B77//jlmzZuk/HyxduhQzZ85EWFiYkrkD8frTaO7s7GwAcMidlpaGPXv2OGQP5OtPo9l9mXkgXn8azW105lp2rT8r6/Wnr9mnTZuGOnXqoGXLlhW+6T48PBzvvPOOw7bY2Fj/BJUgMW7cOPElLgB59tlnKy+QiKxevVoAyPLly/Vty5YtEwDyySefiMgfuadMmSIA5KeffnK5n6ysLImNjZVp06YJAOnRo4fpue2zO+ceMWKEREVFudxvMMz8ww8/FACydu1a5XLbZ/e0VuyNHj1aAMjEiRMrLbfIlc+8cePGcv3110tZWZm+DYBYrVbp27evkrmPHz8uoaGhMnz4cIf71P7bfPzxxwHN/eCDD0poaKjs27dP3zZmzBgBINdee63D1z/wwAMSEREhhw8f1rdt2bJFAMjtt99eabmNZtdmXrt2bZfsJ0+elPz8fIf9zHp8Gp15YWGh7Nixw+U+n3vuOQHgsobMyO5t5u5oc589e7byuVXoT18en6r1py8zV6k/fZm5O2b2py8zV6k/jc7cU3/OnTtXAMiQIUP8nnf37t0SGhqqPw+sWrXK4fbvvvtOAMhLL70kIn/MvGHDhtKhQweHfXv16iUpKSmSm5urb9OeEzdv3qxs7szMTCkqKhIRkdtuu03q1q1baY9PX3OL/LFW7HOfPn1a0tPTXe7/r3/9qwCQhx9+2PTs3mbujrZW7B87ZuQWcT9zb/epynrxNvPOnTtLWlqaw7ZgyP3CCy+I1WqV7777TrncIhWvFXvdunUTAPL000+bnt3TzIuLiyUiIkIGDhzo8PXaOh8/frypuUXcz/z7778XAPLMM884fP3f/vY3ASBjx471a24j2QsKCuTEiRMiIvLDDz/oM3TH3WtQbf8FCxYomzuQrz8vJ3fXrl1dspvx+tOfM3ensl5/+mvm9pxff6q0XhYtWuT2vjy9BvUXZS+F5At317lyJzMzE6NGjdJPuUlLS8N777132d9X+572p+zk5eUBgH66nSYlJQUA9EsH2OeeNGkSmjZtimHDhimXW2OfGyh/F0O9evX0r/NEtZmPGzcOYWFh6NevH8rKyjyemqfizO3XeWFhIdasWQMAiImJUSa7u5kfPXoU6enpLqeJhYWFOeynUu5vvvkGJSUl2Lx5s9v7XrFiRUBzf/nll2jdurXDO1pCQ8tPOPvpp59w4MABffuaNWtQo0YN3HTTTfq27t27AwD27Nnj8L3Myg4Affv2dcn+5JNPolmzZhV+H5VmHhYWho4dO7r0UL9+/QDA5XIiqs3cW3/a36equVXoT18en4Ba/enLzFXqT19nrlJ/+jJzlfrT6My1/jx+/LjDc8uQIUMAAOnp6Q7fyx/ZJ0yYgH79+uHGG290e/vq1asREhKC+++/32H76NGj8c033+iXxsjLy8OmTZtw8eJFl7VhtVqxcuVKJXMDwOTJk/VL8XhjVm5trdjnrl69OtLS0gLan/6ceSD7018zt89+/fXXe71PM7MD7me+b98+7N+/HyUlJbhw4UJQ5C4rK8PUqVNhtVrRtm1blJSUeHz3qaprRVvnJ06cwLZt2xy+xuzsgOvMi4uLcenSJY+v4/zdn/6a+ZdffgkA+PXXX5Xpz/DwcP2SgBVZtGgRLBYL6tSp47A9ISEh4P3pS+5Avv70V24zXn/6c+Yq9acvuYHy7A0bNvT6+lPV7ED5FSwqeg16OZS9FJK/ZWVloX379rBYLHjooYeQmJiIjRs3YvTo0cjLy8MjjzxS4X2ICM6cOYOSkhIcOHAAkyZNQkhICLp06aLvc9NNN6FKlSqYMGECXnnlFf2HnpkzZ+LOO+90uYZVUVERFi9ejK+++srt9bnMyl2rVi0cPnwYANzmLikpwZEjRxAbG4v4+HgMHTpUmeyeZp6Xl4fs7GxER0dj8uTJmDt3rr6v/S9cVZ25vQ0bNri9Bp1qMweA5ORkZGRkYO7cuejTpw8KCgoAlP9yZ8KECUrmLiwsBACP18z78ccfA5q7sLAQ8fHxHu/jxx9/ROPGjZGZmYlTp06hTZs2+ml99k6cOKH/f7OzR0ZGOmQ3yuzcmopynzx5EsAf/04Vsnub+ZkzZ1BaWupwSme3bt2Uzq1Kf/q6VlTqT6MzV60/r+TxaXZ/+rLOVepPozPX+tP5l07av8/fPbRq1Sp8/fXX2Lt3LzIyMtzus2vXLjRp0sTlYIF2KYyff/4ZtWvXxu7duyEiCA8Pd7mP5ORk7Nq1S8ncRpmdW1NR7srqz8qaeXZ2tv7YAcp/dtQeO2bn1jjnzsjIQEFBAV588UWP92l2dk8zLy4uRlRUFIqKivQ3Ctlf6lO13L/99hsuXbqEuLg43H///Vi8eLH+mS2HDh1SJrfG2+NzxYoVbi8/bXZ255lHRESgevXqOHPmDJYtW4Ybb7xR7/2IiAj9F/xm59ZouVXsT6MyMzNRUFDg9ueEmjVrBrw//S1YcpvZn5ejsl9/Vkbu7OxsXLhwAa+99prH3xWpmj0/Px8xMTHIz8/XX4O+8MILqFq16pXfeaWdC+Fn3i6FNGLECKlbt67DNjidjjJ69GhJSUmR7Oxsh/2GDBkisbGx+ulP3pw4cUI/1QWA1KpVSz788EOX/d555x2Ji4tz2HfEiBFSXFzskjssLEyGDh0qIiKHDh1yuZSD2bkBuOSeNGmStGjRQhITE2X58uUyYsQIfV/7U/fMzu48859++kkASJUqVSQpKUnefPNN/dI4AGTjxo1K5HY3cxHHdT5gwAAJDw8PinV+1113ic1mc/k3jho1StncP/74owCQuLg4h6/V9q9atWpAc/fp00fi4uIkLy9P32Z/qubLL78sIn+cAnfDDTe4fU4EIAUFBaZm13J36NDBIbuI4xr3dCqqajN3l11EpHv37gJAnnzySdOzG5m59nyi/enZs6fyuVXpT1/Wimr9aXTmqvXnlTw+ze5PX9a5Sv1pdOZaf7Zu3drhOXHTpk0ClF/GyV/Z8/PzpU6dOvLUU0+JiMi2bdsEcD1VPC0tTbp27eqSe8+ePQJA5s+fLyIiq1atEgCSnJzs8PUApHnz5vp21XKLOK5xT5dCMiu3fXbn3M7ZCwsLpXnz5n5/TqysmdeqVcvl8Wl/+RUVZ56fny9RUVESGxvrcJ+qrBdvM2/UqJHExsbKmjVrZMmSJdK3b1/98alq7rVr1+r92bhxY1m0aJEsWrRI3/bLL7+Ymts+e0WPzzZt2khKSkpQrJV+/fpJWFiYy+Nz3Lhxpue2z26fe82aNW5fx82fP18ASGJiYsCz2/N2eRvtturVqztsByAdO3bUX4OqllskMK8/ryS3t8vyBOL1Z2XOvDJff1bGzMvKyqR69er6JYW0158qrRdPl0KaNGmSPPnkk/Lhhx86vAbt1KmT2989+up/4lJIFRERrFmzBn369IGIIDs7W/9z6623Ijc3Fz/99FOF95OQkIAtW7Zg/fr1mDZtGqpXr+72NMyaNWuibdu2eO2119CrVy8AwLJlyzBp0iSH/X7//XcUFxfjhRdeUC73unXr0LJlSwBwyT179my0adMGkZGRGDJkCN5//33MnDkTAPDbb7+Znt3TzLWvKysrw0cffYQHHngAf/nLXwCUv3thxowZys7cXl5eHj799FP07t3bYbuKMweAkJAQWK1WjBgxAqtWrdJPAfvwww/x+++/K5n72muvRfXq1ZGbm4tFixYhIyMDGzduBABUqVIFly5dCmjuBx54AOfOncNdd92FXbt2Yf/+/frpsgBw6dIlh/8NCQnx+P3Mzq69Y2jnzp0OmY1QcebuzJo1C1u3bgUA2Gw207MbmfnGjRuxYcMGvPLKKwDK3xGocm6V+tOXtaJafxqduWr9ebmPTxX605d1rlJ/Gp35tddei3bt2mH37t24cOGC3p9jxowBUH7Gjr9m/vzzz6O4uBiTJ0/2ut+lS5fcnoWgPT87d6i7d6CFhob6rT/9ndsIFXLb3+7JQw89pD8XVqlSRZnsnmYeEhLi8NgBoL8bXYXc9rfb32dZWZnXD2xUIbu7mXfq1AlxcXHo378/hg8fjo8++ghAeX9+++23Sua278/PPvsMI0eOxMiRI/X9X3zxRSVy29/uzv79+/Hjjz/ql+XRqJDd3VqxWq2wWq0YN24c1q5dizfffBNA+VkX2dnZSuS2vx0Aevfujbp162Lnzp3Iz8/H4cOHsXLlSjz99NMAzOlPoyrqT6D83dKq5TZCxXm7U1mvPysze2W+/qyM3O+//z7Onj3r9QxeVbPPnj0bzz//PAYPHuzwGnTHjh1YvXr1lX+DKz40ESBXcsZCVlaWy9Fq5z/2H0Zo1I4dOwSArF+/Xt/21VdfSUhIiPzwww8OuadOnSoWi0X27NkjIiK5ublis9n0d4uIuL7j0szc9tntc2ucZ56fn6+/Q83s7J5mrh3FCw0NdbhPANKqVSuxWq2SmZmp/Mzfe+89AaB/uKLK61xEJDU1VSIiIhzuE4DYbDYZPHiwsrkHDRrkcBQ9JCREAEhqaqrExsYGNLdI+QdfRkVF6fcdGxur//9//OMfImL8jAWzswOQF1980SG7SMXvGDE7t7uZO2dfsWKFWCwW/cNhVcluZOYabb3PnTtXydyq9ae73EbWisbM/nSX3d3MVetPd7mNzFyF/nSX3dPjU6X+dJfb08yPHTsmNWrU0G8LCQmRxx9/XABIeHi4iFz5zA8dOiQRERHy3nvv6dsCccaCirlFKj5jwczc9tmdc9tn1x4D06dPVya70ZlrtDzr169XcubafXbq1EnP7u6MhWCc+fTp05XMrT2v2Gw2l9z16tWT+vXrK7lWNNrMp0yZIgBk586dyq+V4uJiiYuLk+joaIevB8rPEnniiSeUnXl6erpDt4aHh8ucOXMEgCQlJQV85vau9IyFI0eOKJdbpPJff15pbiNnLFTW689AzFwD+O/1Z2XMPDc3V5KSkqRly5Z6dndnLJid3dMZC+7k5+dLlSpVZPTo0Ya/xpM/xWcsaNcCHDZsGEaMGOF2n2uuucbn++3YsSNSUlKwbNky3H777QCABQsWICkpCdddd53Dvn379sXUqVPx9ddfo3nz5nj55ZdRVlaGqKgo/ZpZx44dA1B+xDcjI0N/p46ZuQFARPTcnmgfgqQdrVZx5qmpqQD+eAeUvaioKBQXF+vvKlF55suWLUNsbKx+PxoVZ37w4EEcP34c1apVc7nfOnXqYMeOHUrmBsqvTZicnIwtW7bg5MmTaNy4MVJSUpCXl4dmzZoFNDdQ/i6+v/71r/j1118RFhaG9957T3/3TZMmTQD88SHUnt5tZLPZEB4ebmr2f/zjH1i1apX+TjktuxEqztxeQUEB7rnnHtx2222YP38+3n33XSWyX87MtfscOHCgcrlV60/n3EbWij0z+9M5u6eZq9afzrmNzlyF/nTO7mnmqvWnc25vM69ZsyZ69eqFrVu3Yvny5WjcuDGSk5Px0ksv6f+eK80+ZcoU1KxZE126dNGfB7RrC58+fRoZGRmoU6cOqlSpgpSUFGRmZrrch3a9am19ax1qf712zfnz55GamqpkbiNUyK1xl/vChQt48sknMXbsWPz973/HM888o1R2X2ZetWpVLFu2TP9ZU6WZa/epfX5LRkaGfp9A+YdmlpWVBd3MASAnJ0fJ3BX1Z2ZmphK5NZ7m/cEHH6Bp06Zo06aNw3YVsjvP/IsvvsC5c+f0z+CwV716dezYsQMTJ040PbfGfuZpaWm48847sWXLFnz44Ydo3rw5IiIiMGHCBFP606iK+jMhIQFWq1W53EaoOG97lfn6M9Az99frz8rI/fLLL6OoqAj16tXDzp07kZGRob/+BMr7s6ioKKhmHhERgWrVqiEnJ+eK7+tPcWAhMTER0dHRKC0tRffu3f163wUFBcjNzdX/npWV5fYJVTutRzuF7ciRIygqKsLx48dRv359h32/+uor1K9fHzt37jQ9t0bL7cn58+cB/PFBMSrOPDU1FTabTd/unN9ms6F+/fqm59a4m3lpaSm2bduGkSNHupxSqeLMs7KyAJQfKHFWVlaGkpISJXPba9y4scOHgF64cAHdu3cPaG5NVFQUOnToAABYtGgRgPJC6NSpE4DyX+YkJia6/eBmoPzDJ4HArhXn7MuWLQMAbN261SG7ESrOXHP69GmcOnUKHTp0wMqVK10+eC3YZl5cXIzc3Fwlc6vWn865Ae9rxZmZ/ampaOaq9adzbqDimavSn87ZPc1ctf50zg1UPPPQ0FDceOONAP641FeDBg0AXPnMjxw5gt9//12/P3sPPvggAODs2bOIi4tDq1atsG3bNuTl5Tl8eOZ3330HAGjVqhUAoEWLFrBYLPoHaNo7efIkevTooWRuI1TIrXHOfeTIEZw5cwYDBgzAvHnzlMzuy8xLSkr80p+VMXPtPn///XcAcOnQOXPmYOrUqUpk93WdJyYmKpn76quvhsVi8fgLV1Vya9zNu7CwEIcPH9Yv92VPhezOMw9Ef1b2zK1WK2644QYAwIYNGwCY059G1axZE+Hh4W77MzMzE61atVIytxEq567s15+Bnrm/Xn9WRu4jR47g7Nmz+iX43PXnyJEjcfXVVyuX3ZPz588jOzsbiYmJV3xff4rPWAgJCcGAAQOwZs0apKenu9x++vRpr19/8eJF5Ofnu2xfs2YNzp496/Du5yZNmiArKwvbt2932Hf58uUAgNatWwMAxo8fj5tvvhmJiYlYt24d1q1bhwULFgAAWrZsiXXr1qFRo0am59ZouQsKCvRfgtibPn06AKBRo0YA1Jw5UP4EUFpaii1btjjsu2/fPnTt2hVWq9X03Br73Pb3X1ZWhrvvvtvlNhVnrq2Hixcvuvxwd/jwYbRu3VrJ3O5oR59DQ0MxduzYgOZ2R3t3zujRox2ukztgwAAcO3bM4QXMZ599BqD8XTBAYNeKJ2vXrnXJXhGzc3ua+d69e/HZZ58hNDQUn3zyif4OdJWyA64zLykp0a8F7ezUqVO47rrrlMytWn+6426tqNifnrh7fKrUn+54enza378K/emJ88xV6093Kpq5pqysDE888QQA6Pd5pdlnzJihP/61P9pj6YknnsC6desQFRUFABg4cCBKS0uxcOFCh/tYtGgR2rVrh9q1awMAYmNjkZKSgosXL7o8VouLizFo0CAlcxthdm7tZxLn3F988QU+//xz2Gw2LFu2zO078MzODrjO/OLFix7fdFVQUOCX/qyMmWv3ad+h2n0CwF133YWoqCjTswOuM8/Ly3P55bz9c+Ott96qZO7o6GjUqlULhYWF2Ldvn8O+R48eRY8ePUzP7enxqbl48SIA6J+tZM/s7IDrzLUz6LTc9rKzs/3Sn5U9c82lS5f0M7hatGgBILAz90XdunVx6dIlHD161GF7Tk5OwPvTn1TNHYjXn5WRPRCvPysj9/jx4136U3v9CZT3Z/369ZXM7u01qIigZ8+ePt2fW1d8MaUAuZLPWBAROXnypNStW1ciIyNlwoQJsmDBApk9e7YMGjRI4uPjvX7vXbt2SbVq1eTBBx+U119/Xd544w0ZOXKkhIaGSr169Rw+7Xvfvn0SFRUlVatWlaeeeko6d+6sX0tLu/azp9zO14g2M/f8+fOlcePGLnkOHTokcXFx0rRpU0lISJA5c+ZI79699X/jlClTTM/ubeaDBw+WkJAQiY6OlmeffVZeffVVAcqvG/3zzz8rOXPNiBEjJCwsTFJTU6W0tFREgmOda/+mm2++WebOnSuzZs0SoPxzJD7//HNlczdr1kyqVq0qb775psyZM0fatWsnAOTOO+8M+LwzMjKkbdu2MmPGDHnnnXdk4sSJ+mc+5OXlOdzvkSNHJDw8XEJDQ+X111+XWbNmSXx8vACQp59+2vTsLVu2FKD8evLO2QcMGCBxcXEyffp0fd7a2lmyZImSM8/Ly5PatWsLAImLi5OlS5fqfwDIqFGjlJ352bNnJTQ0VKpWrSqvvPKKzJ8/X+9am80m+/fvVzK3iFr9aXStqNifvsxcpf705TlRRK3+9GXmKvWnLzMfP368NGnSRF/n7dq1E4vF4teZu+PtGrSDBg2S0NBQefzxx6VLly762tXmqLn99tv1/x5vvfWWPP300wJAGjRooHTuvn376v3ZtGlTiYuL09fOxx9/bGruBQsWSHJysgBwyJ2RkSGxsbESEhIiCQkJLv05duxYfV/VZr5r1y4JDw+X6Ohoh8cOUP7ZI9pjR7WZa+w71N1nLJiZ3dPMt23bJjabTWJiYmTevHny8ssvS6dOnQSAXHvttcrmFhG54447xGKxSEpKisyePVtmz54tACQyMlKOHTtmau6K1so999wjVapUkfbt2+vbVF8rIiIpKSkCQPr16ydvvfWW/hkRVqtV9u3bZ2pubzMfNGiQNGvWTKpVqyYvvfSSNGvWTP/MP7NmPnfuXJk+fbo88MAD+nPF9OnTZfr06XLu3Dl9v4EDB0qVKlWkYcOG+mtQAFKjRg0pKChQNndlv/680twNGjTQs2u5A/X680qzu5t5IF5/XmludzPX2Penu89YMDt7//79XWauvQZ94IEHZM6cOQ6vQXv27Km/NroSf5oDCyLlH6Qxbtw4qV27tlitVklOTpZu3brJwoULvX7v06dPy/333y9XXXWVREVFSVhYmDRu3FgeeeQROX36tMv++/btk4EDB0rt2rWlSpUqAkAee+wxuXjxotfc7n4xYlZuq9Uq0dHRAsAh99mzZ2XYsGESHR0tFotFwsPDJS0tTS+OYJh5zZo1pV+/fhITEyMRERECQO69917Tc3uauebOO+8UAPLoo4/q24Jh5sOHD5eEhARp1aqVVK1aVapWrSoA5J577lE6d6dOncRqtUpUVJRER0dLt27dTJt3Tk6O3HHHHZKcnCxhYWFSv359ufbaaz0+J95xxx1is9kkMjJS4uLi5O6771Ymu7bG3f3y79Zbb9XL2flP586dTc3taeb2P1C4+9OyZUtlZ15YWCjNmjUTq9UqMTExYrVa9Q/8nDBhgrK5RdTqT6NrRcX+9HXmqvSnr8+JKvWnLzNXqT99mfmiRYskPj5eLBaL3p///ve//Tpzd7y98Lp06ZI89thjkpycrHf/pk2bXPYbMWKEJCcnS8eOHcVms0liYqIAkEmTJimdW/sFq7s/I0aMMDV3eHi4/mHe7r7eSO+bld3TzE+fPi1NmjSR0NBQh8cOAHn88cdNz+1p5hojBxbMyu5p5gcPHpS6detKSEiI/jNumzZtBHA8MK9abpHyeaekpEj37t311xUA5KGHHjI9d0VrpXv37gJAXn/9dX2b6mtFRGTYsGESFxcnzZs3l4iICP0DkceMGWN6bm8zf+GFFyQmJkYASHx8vPTt21d27dpl6sy11wbu/hw6dEjfb8SIEZKamiq33HKL/hoUgPztb39TOndlv/6sjNyBev1ZGdkD8fqzMnJrjBxYUC279hq0UaNGEhkZ6fAatKioyOc87lhE3Fx8joiIiIiIiIiIiIiIyI0/xWcsEBERERERERERERGRf/DAAhERERERERERERERGcYDC0REREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGRYqNkBVGOxWDzeJiIBTOKbYM0NBG/2YM0NBG925g68YM0erLmB4M3O3IEXrNmDNTcQvNmZO/CCNXuw5gaCNztzB16wZg/W3EDwZg/W3EDwZmfuwNOyxwCIBpBpd5vK2f8XZu6O6tmd8YwFIiIiIiIiIiIioj+hGACbAHwOoJbJWSi48MACERERERERERER0Z9QNIAaABoC2A4eXCDjeGCBiIiIiIiIiIiI6E8oE0AXAP/FHwcXOpiYh4IHDywQERERERERERER/Ukdg+PBha9NTUPBggcWiIiIiIiIiIiIiP7EjgEYbnYICioWCbaPmyYiIiIiIiIiIiIi/zl6FOjSBTh4sPzv/JUxVYAHFoiIiIiIiIiIiIiIyDBeComIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLDeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDOOBBSIiIiIiIiIiIiIiMowHFoiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsP+Jw4sjBw5EvXq1XPYZrFYMHXqVFPyGBWsuYHgzR6suYHgzc7cgRes2YM1NxC82Zk78II1e7DmBoI3O3MHXrBmD9bcQPBmD9bcQPBmZ+7AC9bswZobCN7szB14wZo9WHMDwZ29Mil7YMFisRj6s3379oBnO3fuHGrUqAGLxYLVq1dfce633noLrVq1QkREBABg8eLF+OWXXwKa+8KFC4azWywWLF68GIcPH3bYBgBLlizxe+6Ksvs68/z8fLRv3x5xcXGoVq0aAGD//v0Bz+3LzLdv3469e/ciMzMT4eHhqFmzJh599NFKyWwku68zLy4uRs+ePVG1alUkJCQAAC5evKh07uzsbOTk5KBNmzawWq36Gq8s3nL/8MMPhrNPmjQJn332GY4dO4aoqCi0aNECM2bMMC27LzPfv38/Tp48iaSkJISHh6N+/fr6/Qc6ty8zt38+Ly4uRvPmzU1dL77k/uqrr9w+l7/xxhtK59ao0J++rBX2p39y+/r4ZH8GNrdK/blnzx72Z4Bz+zJz9qd/cvs6cxHB+fPn9f7Uns9PnjwZ8Oy+5PbUn8899xx69OihbG5Anf70da0Ec38WFhbihhtuQGRkJJKTkwEARUVFAc/tS/aXXnoJO3bswPHjxxESEuLyC8xAZzeae9OmTdi3bx+ysrKQkpKC6OhotG7dGgBQVlambO7t27fj119/xYkTJ5CYmAibzYbGjRsDMOdnLV+zu7vPyuSvmW/atMntc/k///nPgOf2NXtZWRlyc3Nx1VVXwWazISkpCQCQl5dnSnZ7M2fOhMViQYsWLRy2Z2RkeP133XfffVecM/SK76GSLF261OHvS5YswZYtW1y2N2vWDG+//XalPWG5M2XKFOTn57u97dVXX8Wjjz6KatWqITExEfv27QPg+u/Rco8aNQrjx4/HPffcg4ceegj33XcfYmNjcerUqYDmzs7OBgCH3GlpadizZ49L9tzcXERFRUFEYLVaAQA7d+7EnDlz0LBhQ7/nrii7LzNv1aoVFi9ejLZt2+L5559HQUEBJk6ciOXLl2PgwIHo379/wHL7MvPVq1fj+++/R79+/XDLLbfgt99+w9y5c/2a1Zfs119/Pfbv34+2bduiTp062L59O/773/8iPDwczz77LGrXrg2gfObPPvssPvnkE/z++++YNWsWLly4gKeffhpLly7FzJkzERYWpmTu1q1bY/PmzbBYLGjQoEGl/fBvJPcLL7yA2NhYPfe5c+ewfv16FBUVYdasWXrugoIC3HfffWjbti3uvfdepKam4ptvvsGzzz4LABCRgGf3ZeZXX301GjZsiFatWiE+Ph6HDh3CjBkzsHDhQjzxxBNITU0NWG6jM9eyaz00d+5cHDlyxK85fc3uy8w7duyIo0eP4t1339W/fvjw4ZXyAt2fuVXqT1/Wimr96cvMVepPX2auWn/+7W9/w7/+9S80atQI8fHx2LFjB/7zn/8AAP7617+ia9euANTrT19yq9Sfhw8fxtVXX63nLioqwieffIJz58455FaxP32ZuUr9aXTmWnaV+tOXmavUn77OXESQm5uLO++8Ew899BAuXryIRx55pNJ+keavmS9atMihP4HymQPALbfcomxulfrTl7WiWn/avz7OycnBxIkTUVZWhpo1a+L555/Xb2vWrBnGjRuHFStWID8/H6+++iqOHTuGmTNnYuXKlZg1a1ZAc9tnz8nJweOPP46SkhKUlZW5vOZfv349jh49ijZt2uDYsWN+z+mOP2Zus9nw3XffoWvXrujZsydiYmKwefNm/Pzzz/joo48wbdo0JXM3a9YMdevWRZs2bZCWlobo6Gjs3bsXr7zyCt59911MnToVUVFRActtn72itWLfn48//rjX+/QXf828SZMmCA0Nddg+fPhwdOrUKeC57bNXNPNGjRohMzMThYWF6NmzJ6655hqcPXsWjz32GAoKCkzJrjl27BhmzZrldr0mJia6/FsAYNOmTVi2bJl/+lOCxLhx48SXuADk2Wef9XuO3bt3S2hoqEybNk0AyKpVqxxuLygokBMnToiIyA8//CAAPOb+8MMPBYCsXbtWydxdu3Y1PPPRo0cLAJk4caIS2T3lbty4sVx//fVSVlambwMgVqtV+vbta3pudzM/fvy4hIaGyvDhwx22z507VwDIkCFD/JrbSPYdO3ZIYWGh/nft8RkeHi533323w74PPPCAREREyOHDh/Vt2n+jBQsWKJv75MmTkp+f77CfWY9P59wiInfffbcAcMhdWFgoO3bscLn/5557TgC4rCEzsnubuTva3GfPnm1qbhH3M7eXlZUlsbGx+n2qsl68zXzEiBESFRXlsC0YcqvUn5ezVuyZ2Z++zFyl/jQ6cxX705k285YtW0rTpk0dblOpP33JrVJ/uvPggw8KAIfcKvanM28zd8es/nTH3cztqdKfzrzNXKX+dMfTzN31p4g62S93nR89etRfkUXEv7lV6k933K0V1fvzrrvukpo1awoASUtLc7m9V69ekpKSIrm5ufo2ba1s3rzZ1Nxdu3aV1NRUt7+vyMzMlKKiIhERue2226Ru3bp6drMfn95mfvr0aUlPT3f5Gm3mBw4cUDK3J1ru5cuX+yuyiPh3rXi6T9XXiohI586dXbarktvbzF944QWxWq3y3XffOWxXKbu72XrSrVs3iYmJkUuXLl1xVmUvheQLd9e5ciczMxOjRo3STxNOS0vDe++959P3mjBhAvr164cbb7zR7e3h4eH6qXYVGTduHMLCwtCvXz+UlZV5fJeIarkBx5kXFhZizZo1AICYmBilsx89ehTp6ekup4mFhYXpl9JQLfc333yDkpISHD9+3GGdDxkyBACQnp7usH8gsnfs2NHtOyXT0tKwd+9eh22LFi2CxWJBnTp1HLYnJCRg5cqVyuZ+8skn0axZswq/p1m54+LiAMAhd1hYGDp27OjynNivXz8AwOnTp5XIDrifubfncvvLOag0c/vsDRs2RNOmTTFs2DCP31e1mX/11VfIz89HaWmp11M4VcutUn9ezlpRpT99mblK/Wl05ir2pye1a9d2uWyNSv3pS26V+tMdbQ3b51axPz1xN3OV+tMddzPXqNSfnribuUr96Y6nmb/66quoXr26/m5Sb2cpqDZz53VeWFgIAKhbty5q1aqlbG6V+tMdd2tF5f784osvsHr1ao/75eXlYdOmTbh48aLLz1ZWq9W0/tRyv/baax73SU1NxX333afM77acs3var3r16njppZc85rb/2Uyl3ICa/WlkrWjZr7/++grvU7WZ79u3D/v370dJSQkuXLigVG5PMy8rK8OcOXNQs2ZNDB48GCUlJV7PJFApuzsnTpzAtm3b0L9/f9hsNp9yuaPspZD8LSsrC+3bt4fFYsFDDz2ExMREbNy4EaNHj0ZeXh4eeeSRCu9j1apV+Prrr7F3715kZGRcUZ68vDxkZ2cjOjoakydPxty5c/UH1Z49e5TN7c6GDRvcvlBQMXtycjIyMjIwd+5c9OnTRz9lqbCwEBMmTFAyt/ZDc2io48M1MjISQPmTgsbs7FlZWUhLS9P/npmZiYKCAsTHx7vsW7NmTezatUvJ3L58nVm55f8uy1C9evUK99WumautGbOza9/f08zPnDmD0tJSh0sidOvWzfTc3maenZ2NCxcu4LXXXvN4fUtVZy4iiImJQX5+vv5Ytb8GrWq5g6E/jT4+Ve1Pd2tF9f50N3OV+/PixYu4dOkScnNzAQAbN27EXXfdpd+uan9WlNsoM3P//PPPAP7oFW9U6E9fZq5SfxqduYr9aXTmqvVnRTPPy8vD999/j6ZNm+LEiROIjY3FhQsX9M/ksKfqzO1t2LABAHDNNdconVvF/qxorajan6WlpXj44Ydx7733umTT7N69GyKC8PBwl9uSk5NN6U/73FdffXWF91sR1WZeEe1nM5VzZ2dno6SkBAcOHABQfsCtS5cupuauaK1kZGSgoKAAL774osf7VHXmxcXFiIqKQlFRkf45BaWlpabn9jTz3377DcePH0fr1q1x4MABPbu7/VXL7s6KFStQVlaGu+++2/DXeHXF5zwEiLdLIY0YMUI/TUwDp9NRRo8eLSkpKZKdne2w35AhQyQ2NlY/ZduT/Px8qVOnjjz11FMiIrJt27YKT0fxdlmen376SQBIlSpVJCkpSd58801ZtmyZvv/GjRtNz+3tUkj2Mx8wYICEh4crP3OR8lOEbDabvo/2Z9SoUUrkdjfzH3/8UQBI69atHdb5pk2b9NNozcwu4nipg3fffdfl31W9enWH/QFIx44dBYAUFBQol1vEcY17upSDWblFRLp37+42t3N2+32ffPJJ07Mbmbn2fKL96dmzp+m5RTzPvKysTKpXr65fEuHQoUNKrRdvM2/RooXExMTIhx9+KMuXL5cRI0YIAKldu7YUFxcrmVvl/tQYfXyq1J8i3teKqv2pcTdzlftzzJgxDnMcOHCg5OTk6Ler2p8V5RZRsz+dcwNwye2cXUSN/vRl5ir1p5GZq9qfRmauYn9WNHOtP8PDw6VKlSp6f7Zt21YAx0vJmZ29oucWkfIODYbHp4r9WdFaUbU/33jjDYmNjZVTp07p/eJ82Y9Vq1YJAElOTnbYDkCaN2+ubzcrt4h4vbyNts69XQpJtZnb59YUFhYKAImLizPlOdGX3LVq1XJ5PAwcOFDfR8W1kp+fL1FRURIbG+twn8GwVho1aiSxsbGyZs0aWbJkifTt21d/fJqdW8T9zNeuXav3Z2hoqCxatEgWLVokjRs3FgAyduxYJbIbvRRSmzZtJCUlRUpLSyvc14j/iUshVUREsGbNGvTp0wciguzsbP3PrbfeitzcXPz0009e7+P5559HcXExJk+e7JdM2rsry8rK8NFHH+GBBx7AX/7yFwBAREQEZsyYoWRuZ3l5efj000/Ru3dvh+2qZg8JCYHVasWIESOwatUq/XSkDz/8EL///ruSua+99lq0a9cOu3fvxoULF5CRkYGNGzdizJgxAICSkhIA5s787NmzAIAOHTpgxIgR+vZLly4BgNt3oGlHsfPz85XLbYSZ8963bx8+//xzAKgw96xZs7B161YA0E9zU3Gt2Nu4cSM2bNiAV155BUD5OxrMzu1t5u+//z7Onj3r9p3FGlVn3qZNG8THx2Pw4MEYMmQI3n//fQDlp+2vXr1aydyq96fRx6eK/eltrajcn55mrnJ/PvLII9iyZYv+DtHS0lKHdzqr2p8V5TbCzHkvXrwYdevWBYAKc6vSn77MXKX+NDJzVfvTyMxV7M+KZq71Z2FhIWrUqKH352effQag/HIKgLozt6d1KKD+41PF/qxorajYn2fOnMGUKVPwzDPPIDEx0eN+FfXnpUuXlMxtVLBkf+ihhwAAvXv3RmhoqNK5Q0JCsGXLFqxfv17/oGnt8aBq7ueffx5lZWWIjY31uI+q2Tt16oS4uDj0798fw4cPx0cffQSg/KyAb7/9VsncWn8WFxcjOTkZI0eOxMiRI/WfE3fs2AFA3Znb279/P3788UcMGTIEVar46ZCAP45OBMKVnLGQlZXlcgTS+Y/zB1jZO3TokERERMh7772nb7vSd89rt4WGhrrkbtWqlVitVsnMzDQ1t5EzFt577z0BIKtXr1Z+5iLlRx8jIiIctgEQm80mgwcPNj23p5kfO3ZMatSooWcICQmRxx9/XD9qKmLezE+cOCExMTECQDIzM93+u7y94/LIkSPK5Rap+B2XZs67QYMGUrVq1QofnytWrBCLxaJ/OKwK2Y3OXKOt97lz5yo589zcXElKSpKWLVvq2d294zLYZg5ARo8erWRulfvTl8enav1Z0VpRtT8rmrnK/SnyR7/06NHD4cM9Ve5Pb7lF1O1P5+zOue2zq9af9rkrmrlGhf50zm6fW/X+tM/ty8zN7k/n7O6eV6pWreo2e5UqVaS4uDgoZq51aDCsFVX70zm7c27V+nPs2LHSqFEjKSwsdMh9OWcsmJlb5MrOWFBx5va5RURefPFFUx+fl5tbo+VZv369kmtFu89OnTrp2d2dsRCMM58+fbqSM7d/XnGXPS4uTkTMnbmIsTMWpkyZIgBk586dXvfzxZ/iMxbKysoAAMOGDfP47kH7azM6mzJlCmrWrIkuXbro17fSrrl6+vRpZGRkoE6dOj4d7UlNTQUAt18TFRWF4uJi/aiYSrmdLVu2DLGxsbj99tsdtqs484MHD+L48eOoVq2ay2116tTBjh07lMwNlF9PuVevXti6dSuWL1+Oxo0bIzk5GS+99JL+7zEje25uLnr16qVfh1Nb15qUlBQAjtfL05w/fx4JCQmwWq3K5TbCzHmfO3cOffr0wfLlyz3ef0FBAe655x7cdtttmD9/Pt59910lsl/OzFNSUrBs2TIMHDjQtNyeZv7yyy+jqKgI9erVw86dO5GRkYFjx47pt587dw5FRUVBN/PIyEjk5OQomVvV/vTl8Qmo1Z8VzVzV/jQyc1X709nAgQMxZswY7N+/H02bNlW2PyvKbYQK8waAH374wW1u1frTmS8zN7M/3bGfucr96cyXmZvZn+7Yz1x7bvf0QY3ahzmrkL2imWsdqn22gZZftdyq9qc7zs+JKvXnf//7XyxcuBCvvfYajh8/DgD6h6YXFxcjIyMDMTExSEhIqLA/U1NTTc1tn80+t1Eqztze+++/jyeffBJjx47F/Pnzgya3s6pVq2LZsmW47rrrTMsNuF8r2n1qn9+SkZGh3ydQ3p9lZWVBN3MAAe1PX2Zu358i4vI9tTOlzM5eUFBQ4cw/+OADNG3aFG3atPGYw2d+O0RRya7kjIWSkhKJjo6WoUOHXtb37ty5c4VHnc6ePevydRW9e95ms0lISIhL7muuuUZsNpsUFRWZmruiMxZq1aolVapU0a8PqfrMv/76awEgCQkJDtsBSKNGjSQpKcn03EY/10JEZM+ePQJAbrjhBhEJ/MwvXbokN954o0RGRurXOHUnPDxcIiMjHbZp/x26du2qbO6K3nFpZu6vv/7a63Ni7969xWKxSMeOHfVr+KmS3ejMNQAkKSlJmjVrpuTMtWsqe/uza9euoJs5ALn//vuVza1af/ry+FStP43MXMX+9HXmKvWnPS33a6+9JgDku+++029TrT+N5latPz1ld84tol5/ustd0cw1Zvanp+z2uVXtT3e5fZm5Wf3pKbtz7uTkZImMjPR4hktpaanyMz9+/Ljeoao/PlXsT0/Z3T0nqtKf9u/G9vRnwoQJIiJy7tw5sVgsEhMT4/C9gPLPhhg1apSSuTUVnbGgavYRI0ZIYmKihISEyIABA6S0tDRocrt7PrTZbNKrVy8lcxu9TxWze5s5AJk1a5aSufPy8sRqtUqNGjXcZtee41XMbu/bb78VADJt2rTLyufJn+KMhZCQEAwYMAAffPAB0tPT0aJFC4fbT58+7fWaVDNmzEB2drbDtvT0dDzzzDN44okn0KFDB0RFRfmcq379+ti7dy+2bNmCHj166Nv37duH7t27w2q1Kplbo72jxd0nias480aNGum5RcThuouHDx9Gt27dlMztTllZGZ544gkA0I+iBzJ7aWkp7rrrLnzzzTf46KOPsGHDBo/3W7duXRw4cABHjx5F7dq19e05OTkYNGiQsrkrYmbuDh06YNmyZW7vd+/evfjss88QGhqKTz75BBEREUpl9zTzkpISj9fSPXXqFG655RYlZz5+/HjceeedeP3115Geno6FCxfi1KlT+jVo77rrLtSvX1/JmWvvaPCkZ8+eSuYG1OpPXx6fGlX60+jMVevPy5m5xuz+PHXqFGrUqOFyH0uWLEFERASaN2+ub1OpP33JXRGzc2vvJnPOrVp/Gp25av1pdOYq9qfRmavWn76s87vuugtz5sxBQUGBvk37PvXr19ff1a7azO2tWLFC71Dt8woANR+fqvWnL2vFmZn92aJFC6xbt85hv4ULF2Ljxo2oU6cO5syZg4YNGwIAYmNjkZKSgqysLJw/fx7R0dH61xQXFwe0P93lBoDRo0cjJycH69at03MbpeLMASArKwunT5/GzTffjGXLlrmcIaNi7osXL+qfF+KsoKAA1113nZJrRbtP+/7U7hMof56PiopScuZ5eXkuZxOJ3RkAt956q5Izj46ORu/evfHxxx/rZ0UB5T87AkCDBg0AmLvOAeDvf/87zp8/7/L41HzwwQcAoH8+od/49TBFJbqSMxZERE6ePCl169aVyMhImTBhgixYsEBmz54tgwYNkvj4eJ/zeLtu4dy5c2X69OnywAMP6EeLpk+fLtOnT5dz587p+w0ePFhCQkIkOjpann32WXn11VcFKL9u9M8//2x67gYNGujZ7XOLlM88LCxMUlNT9U8SD4aZa5/afvPNN8vcuXNl1qxZAkAsFot8/vnnpuf2NPPx48dLkyZNJCEhQebMmSPt2rUTi8Vi2swnTJggAKRPnz6ydOlS6d69uwCQpUuXytKlSx32HThwoFSpUkUaNmwor7/+uj7zGjVqSEFBgbK5BwwYIHFxcTJ9+nRp166dvq5uvvlmWbJkiam5nbNr8vLypHbt2gKUX+dP23fp0qUCQH93tJnZPc387NmzEhoaKlWrVpVXXnlF5s+frz/v22w22b9/v6m5Pc1cY99D7q4RbWZ2TzM/dOiQWK1WiY6Oljlz5sicOXOkd+/eAkAaNmyoP7erlltErf68nLWiSn/6MnOV+tOXmavWn3feead07dpVpk6dKm+//bZDv7zyyisO+6rUn77kVqk/nXNPnz5d4uLiXHKr2J9GZ65afxqduUal/jQ6c9X605eZnzx5UiIiIsRisej92aRJEwEgY8aMcdhPpZmL/LFW2rRpo3eo6mtFRK3+9GWtqNafzrxdw/32228XANK6dWt566235Omnn9Zfa5udW8TzZyz88ssv0rp1a4mLi5OmTZvqXQpAhgwZYnp2TzPPyMgQq9UqFotF5s2b59Cf/fr1k19++UXJ3Lt27ZLw8HCJjo6W119/Xd544w0ZOXKkAJDY2FjJzs42NbeIsc/jsL9P1R+f27ZtE5vNJjExMTJv3jx5+eWXpVOnTgJArr32WtNzi3ie+Z49eyQ0NFRCQkJk9uzZMnv2bElJSREAMnHiRCWye/uMhZKSEklKSpL27dv7nKEif5oDCyLlH6Qxbtw4qV27tlitVklOTpZu3brJwoULfc7j7T9u3bp19Qe1859Dhw455K5Zs6b069dPYmJiJCIiQgDIvffeq3RukfIfSgDIo48+qm8LhpkPHz5cEhISpFWrVlK1alX9wx7vuecepXMvWrRI4uPjxWKxSHR0tHTr1k3+/e9/mzbzik7RsjdixAhJTU2VW265RSIjI/UfXv/2t78pnfvWW2/1uF/nzp2VzG3/gtzdn5YtWzrcr0rZCwsLpVmzZmK1WiUmJkasVqv++HA+jU+l3BojvxhRLfvZs2elQYMGEhoaKpGRkRIeHi5paWkCQP7+978rm1tErf70da2o1J++ZFepP33JrVp/Ll++XLp37y5JSUkSGhoq4eHhAkA++ugjl/tQqT99ya1Sfzrnjo+Pl1q1armsExX70+jMVetPozPXqNSfRmeuWn/6OvP+/ftLZGSk3p/apVhVnrnIH8+J9h0aDLlV6k9f1opq/emsog+HTU5Olo4dO4rNZpPExEQBIJMmTTI9t4jnX1wuWrRIqR5y5u2Xxd461H69qJT79OnT0qRJEwkNDZWoqCgJCwvTDwQ+/vjjDvuqtlZEjB1YMCu7p5kfPHhQ6tatKyEhIWKz2SQyMlLatGkjAGTKlCmm5xbxPvPbb79dbDabREVFSXR0tNxxxx3KzFzE+4GFTZs2CQB5/fXXfc5QEYuI3XknREREREREREREREREXlSpeBciIiIiIiIiIiIiIqJyPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhoWaHUA1FovF420iEsAkvgnW3EDwZg/W3EDwZmfuwAvW7MGaGwje7MwdeMGaPVhzA8GbnbkDL1izB2tuIHizM3fgBWv2YM0NBG/2YM0NAP+1WNAFwDEAtQBsB9AQwH8BNFQ4e7DOPFhzA8GbPVhzA8Gd3RnPWCAiIiIiIiIiIvof0RDlBxM6wPGgQhfTEhHR/yKesUBERERERERERPQ/4r8oP5jw9f/9/XBoKLqUlOCYiZmI6H8Pz1ggIiIiIiIiIiL6HzHc6e9P167NgwpE5Hc8sEBERERERERERPQ/YqnT3587dAi1TElCRP/LeGCBiIiIiIiIiIjof4T2mQod8cdlkbYDPLhARH7FAwtERERERERERET/I7QPav7m//7X/uACEZG/WEREzA5BREREREREREREfnD0KFC7tuPfu3QBatQAvvnGtFhE9L+FBxaIiIiIiIiIiIiIiMgwXgqJiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDOOBBSIiIiIiIiIiIiIiMowHFoiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsN4YIGIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLD/icOLIwcORL16tVz2GaxWDB16lRT8hgVrLmB4M0erLmB4M0erLmB4M3O3IEXrNmDNTcQvNmZO/CCNXuw5gaCNztzB16wZg/W3EDwZmfuwAvW7MGaGwje7MwdeMGaPVhzA8GdvTIpe2DBYrEY+rN9+/aAZzt37hxq1KgBi8WC1atXX3ZuEcH58+fRqlUrVK1aFUlJSQCAo0ePBjy3L9m3bt2Kn3/+GZmZmQgPD0eDBg0wY8aMSslsJLuva6WwsBA33HADIiMjkZycDAAoKioKeO7t27cbzv7SSy9hx44dOH78OEJCQlyezAKd3WjuTZs2Yd++fcjKykJKSgqio6PRunVrAEBZWVnAc/sy83vvvReffvopjh49CpvNhsaNG+ORRx6plMxGsl/uc6J2nwDw22+/KZ1706ZNOHz4sMN2APjnP/8Z8Ny+rJXt27ejrKwMubm5uOqqq2Cz2fTn87y8vIBnN5p7xYoVWLx4sduZP/fcc7jvvvsCmtuXmf/73//Gf/7zHxw/flzvz169evk9r9Hsvq6Vc+fOoUGDBnqHAuY8JwZrf/qSnf3pn9y+ZGd/Bj63Sv3pa3b255Xn9iU7+zPwuQF1+nPkyJHszwDn9mXm7M/A51apP31ZK+xP/+T2Zeaq9WdF2TMzM/V9i4uL8dxzzzn054wZM1BSUuKXnKF+uZdKsHTpUoe/L1myBFu2bHHZ3qxZM7z99tuVVhLuTJkyBfn5+W5vs8+Xk5ODiRMnoqysDDVr1sTzzz+v39asWTPEx8cjJycHvXv3xoMPPohz587hySefxKJFizBmzBi0bds2YLnts+fk5ODxxx9HSUkJysrKXGY+d+5c/PLLLxg5ciTatWuHb7/9Fs8884xfs/qSffLkyZg1axZuueUWNGjQAF999RXS09MxduxYXHPNNYiOjgZQPvNx48ZhxYoVyM/Px6uvvopjx45h5syZWLlyJWbNmhXQ3BotNwA9+5tvvqnnBoD169fj6NGjaNOmDY4dO+b3nO74Y+Y2mw3fffcdunbtip49eyImJgabN2/Gzz//jI8++gjTpk0LaG6NkZkvX74cd955J5o2bYr4+Hjs3bsXb7/9NoDKeyHgr3Vu/5xoZB6q5G7SpAlCQ0MdniuHDx+OTp06BTy3xshaadSoETIzM1FYWIiePXvimmuuwdmzZ/HYY4+hoKAg4NmNzrxt27ZYtGgRRARWq1X/+uHDh+v/9kDm1hiZ+cqVK/Htt99i6NCh6NKlC86dO4cFCxYAgMMPUYHK7ss6v3TpEnJzczFw4EBcd911+Pbbb3Ho0CF8+umnAX9OXLp0KXbv3o1XXnkF9erVQ0hICPbv34/bb78dZWVlGDp0qJ5btf584okn9Nzt2rXDrl27sHfvXvTu3VvPDajXn0ZnrmJ/Gp25av3pyzpXqT99ya1afxpdK6r1p9GZq9ifRmeuWn/6ss5V6s8pU6bg1KlT+t+13g8LC0P16tXxwgsv6LlV6s8xY8YgIiLCYZuWPTU1Vc8NqNefRmeuWn/6MnPV+tOXda5Sf/qSW6X+9GWtqNafRmeuWn/6MnPV+nPMmDHo3r27wzYRwdixY1GvXj3UrFlT3z5s2DCsWrUKo0aN0vvzmWeewZEjR7Bw4cIrDypBYty4ceJLXADy7LPP+j3H7t27JTQ0VKZNmyYAZNWqVR73veuuu6RmzZoCQNLS0hxuKy4uloiICBk4cKBLbgAyfvx4U3N37dpVUlNTXWb+/fffCwB55plnHLb/7W9/EwAyduxYv+Y2kn3btm0O272tlV69eklKSork5ubq27SZb9682dTc3rJnZmZKUVGRiIjcdtttUrduXT27Gevc6MxPnz4t6enpLtu1mR84cMDU3N6yu7N69WoBIAMGDPBrbhH/rnNP9zlo0CClc3fu3NnluVKVNe4t+wsvvCBWq1W+++47JbNfTn+GhYXJpUuXTM0t4j67p/48ePCgAJC2bdv6NfflZPc0c08dqj0n/vLLLwHNnZubK0lJSdKvXz8pLS0Nmv50zi0SPP1pdOaq9acvM3fHzP70ZZ17uk8z+tOX3Cr1py9rRbX+vJy1Ys+s/jQ6cxX70+jMVetPZ1puADJz5kyH21TqT3f69+/vNrdq/enM08xV6093PM3cHTP705m3de7pPs3oT19yq9Sf7nhaK6r1pzMja8WeWf3pjruZq9if7nz55Zcu2b39DtdisfilP5W9FJIv3F3nyp3MzEyMGjUKSUlJCA8PR1paGt577z2fvteECRPQr18/3HjjjV73++KLL7B69WqP+xUXF+PSpUvYvHmz29vtj5qZkfu1115ze/uXX34JAPj1118dZj5kyBAAQHp6usP+gcwOAOfPn/d49kpeXh42bdqEixcvIiYmxuE2q9WKlStXmprb22lIqampuO+++5Rb54D3mVevXh0vvfSSx9x79+41NXdFp345P7do/9/5XQAqzdw+d0X3qVruffv2Yf/+/SgpKcGFCxc87qfSWikrK8OcOXNQs2ZNDB48GCUlJV7foaPazJ3X+IkTJwCUv4PHZrOZmtvTzLX+TE9Pd8iunXJt/+4Xs7J7mrnWoe+++67b2z/88MOA5v7ggw+QlZWFmTNnokqVKiguLna7n2r96Zz74sWLEBG3+6rWn0Znrlp/+jJzQK3+NDpz+9wq9KcvuVXqT6NrRcX+vJy1ojGzP43OXMX+NDpz1frTE4vFgr/85S/631XrT3f2798PAA65AfX60xPnmavWn+54mjmgVn964jxz+9wq9KcvuVXqT3fcrRUV+9MTb2tFo8rrT427mavYn+588MEHLjPX+lP7na1myJAhEBGH/rxcyl4Kyd+ysrLQvn17WCwWPPTQQ0hMTMTGjRsxevRo5OXlGbp23apVq/D1119j7969yMjI8LhfaWkpHn74Ydx7770IDXU/4oiICFSvXh1nzpzBsmXLcOONN+LcuXP6bffff7+pua+++mq3+xQWFgKAy78rMjISwB9PCoHODgB//etfceHCBf0abTt37sR1112n3757926ICMLDw12+Njk5Gbt27TI1d0hIiH5dvMul2swrUr16dVNzG5l5WVkZTnn5OtIAAQAASURBVJ48iQMHDmDSpEkA4FAmqs48Pz/f632qmru4uBhRUVEoKirS/9uUlpaantvTWvntt99w/PhxtG7dGgcOHNCzu3sOVXXm9lasWAEAuOaaa0zP7WnmERERaNeuHX788UfExcXhyJEjOHfuHKZPnw4AaNOmjenZPc1c61Dtdmc//vhjQHNv3boVMTExyMzMxJ133qn/IP3AAw/gH//4h/7DvWr96S639nNJQUGBw4sSo1SbeUUC3Z+XM3NV+tPXmavSn77mVqU/ja4VFfvzSh6fZvan0Zmr2J9GZ65afzrT3lDQsWNHh+c51frTWXFxMQ4cOAAAhg4guKPazCti1utPjZGZq9Kf7nIBnmeuSn/6mluV/nSXy91aUbE/nfny+FTh9afG08xV7E932VeuXOkyc60/nS/5pP0OV+vPK3LF5zwEiLdTUUeMGKGfmqeB0ylAo0ePlpSUFMnOznbYb8iQIRIbGyv5+flev39+fr7UqVNHnnrqKRFxf8kGzRtvvCGxsbFy6tQpPbfz6VUiIv369ZOwsDD9FCHtz7hx40zPLSJuL4W0Zs0aASA33HCDw8znz58vACQxMTHg2Xfs2CEDBgyQd999Vz766CNp3769ABCbzSY//fSTvt+qVasEgCQnJzt8PQBp3ry5vt2s3LNnz5bw8HAB4JBbo61zb6eiqjZz+9yawsJCASBxcXFSXFxsau6KZj548GCHx2atWrWCYubDhg2TkJAQl/u0PxVVxdyNGjWS2NhYWbNmjSxZskT69u2rPz7Nzu1praxdu1YASHh4uISGhsqiRYtk0aJF0rhxYwEcLw+n4sydH59t2rQRADJlyhTTc3t7fB44cEASEhIcHp8NGjRQ/vGpdWj16tUdvl77N7Ro0SKgua+55hqJjIyUyMhIefjhh6Vnz556liFDhuj7qdafzrnXrFkjV199tUtujUr9aXTm9rk1ZvanrzNXqT99mblK/elLbpX60+haUbE/r+TxaWZ/+vL4VK0/jc5ctf50dttttwkAefPNNx22q9afztavX6/P0B2V+tOZp5nb59aY2Z/OKpq5Sv3pzNvMVepPX3Kr1J/OPK0VFfvTmS+PTzP705m3x6dq/ekpu/PMtf5cunSpw3btd7haf16J/4lLIVVERLBmzRr06dMHIoLs7Gz9z6233orc3Fz89NNPXu/j+eefR3FxMSZPnux1vzNnzmDKlCl45plnkJiY6HVfq9UKq9WKcePGYe3atXjzzTcBlB+xy87OVjJ37969UbduXezcuRP5+fk4fPgwVq5ciaeffhoA9EtXBDJ7x44dsXr1aowaNQp9+/bVjxZaLBY89dRT+n6XLl3StzsLDQ3FpUuXTM09adIkDBo0CAAcchul4szdeeihhwCUr6XQ0FClZx4eHo6kpCSsX78e06ZN09/holF15rt37wYAj/epau5OnTohLi4O/fv3x/Dhw/HRRx8BKH9XxrfffqvkWtFOmS0uLkZycjJGjhyJkSNHYuvWrQCAHTt2AFB35vb279+vv2NBe55UceYAEB0djbi4OERHR+v9qfWPdiqwijPv3bs3oqKikJOTg7Vr1+odqu0b6B66cOEC8vPzcc899+D1119Hw4YNAZR/GNiKFSv0d+yo1p/Oufv374+bbroJABxyG6XizN0xsz99nblK/enLzFXqT19yq9SfRteKiv15uY9Ps/vTl8enav1pdOaq9acz7UyLwYMHO2xXrT+dffDBB6hS5fJ/JaTizN0xsz+dVTRzlfrTmbeZq9SfvuRWqT+deVorKvanM6OPT7P705m3x6dq/ekuu9VqdZm59jvcxx57zKE/n376ab2HrtgVH5oIkCs5YyErK8vhqJK7P2vXrvX4vQ8dOiQRERHy3nvv6ds8HTUaO3asNGrUSAoLCx1yu/vw5ri4OImOjnbJXaVKFXniiSdMzS3i/owFEZH09HSJjY3VM4SHh8ucOXMEgCQlJYlIYGfuTJv5kCFDJCwsTEpKSkTE2DtGzMxtn90+t6aid4yoOHP73CIiL774op5Fhdz22b3NXLNjxw4BIEOHDjU9u6eZHzp0SEJCQqRatWou96m9Y0TF3CKen8sByPTp05VcK/bPK+6yx8XFiUhwzHzKlClB8fgsLi6WFi1ayFVXXeUw8/379wsA6dixo+nZvc38jjvuEKvV6tChACQyMlJatmwZ0NxpaWkCQD7//HOH3J9//rkAkMWLF4uIev3pnNs+u31ujUr9aXTm9rlFzO/Py525xsz+NDpz1frzcteKRssT6P40ulZU7M/LnbnZ/Wl05ir2py8zV6k/7Z0/f15CQ0MFcH3drFp/OueOjIyUunXrus0uolZ/Omf3NHP73CLm96dzbqMz16jy+tPbzFXrT6O5RdTqT+fcntaKiv3pnN3ozM3uT+fcnmauYn+6y3777be7vT09PV2aN2/u0J9z5syRGjVqSMuWLT3er1F/is9Y0K7vNWzYMIwYMcLtPvbX83I2ZcoU1KxZE126dNGvb3Xy5EkAwOnTp5GRkYE6dergv//9LxYuXIjXXnsNx48fB1D+gU1A+dHEjIwMxMTEICEhAV988QXOnTvn9vrR1atXx44dOzBx4kTTcgN/XFfOPjcApKWl4c4778SWLVvw4Ycfonnz5oiIiMCECRNQrVo1AIGbubej/bVr10ZRUZH+YVkpKSkO/y5758+fR2pqqhK5ATjkNkqF7M4zt/f+++/jySefxNixYzF//nylcgPGZt6xY0cA5R9erkp255lPmTIFkZGRsNlsLvd58eJFZGRkICwsTLncFcnJyVFi3oDjWklNTQUA2Gw2tx+UqL0DQIXsFc38gw8+QNOmTfGf//xH36ZCbsBx5l988QXS09PRo0cP/d0wANC4cWMAwNGjR5XJ7m7mcXFxSE1NxaeffoqzZ8+iefPmqFatGvLz89GkSZOA5k5NTcWePXtcfhbRPojs7NmzAKBcf3rKrdFyG6VCdueZ21OhP6905mb2p9GZq9afl7NW3Al0fxpdKyr25+XO3Oz+NDpzFfvTl5mr1J/2/t//+3/6u1adqdafzrnz8/PRtGlTHD582OP9e6PizO2p0J/OuX2duSqvP73NXLX+NJq7Ima+/vS2VlTsT+fsRmdudn865/Y0cxX70132u+++2+39pqWlIT09Hb/99pvenxEREZg4cSI6d+7sMY9Rf4oDC4mJiYiOjkZpaSm6d+/u89cfOXIEv//+Oxo0aOBy24MPPgig/IeezMxMlJWVYfz48Rg/frzDfvv370f9+vUxYcIEvPbaa8jKygIAt08EZWVlKCkpUSI3AIfc9qxWK2644QYAwIYNGwBA/16Byh4XF+fxPg4ePAibzYaqVasCAFq0aAGLxaJ/eIm9kydPokePHkrkBuCQ2ygVsjvPXJOfn497770X/fv3x7x58xx+sFMhN+DbzLU1pEJ255kfOXIE58+fx/nz51G/fn2HfTds2ID69esjOztbudwVSUxMVGLegONaufrqq2G1WpGfn+/ygUgAEBUVpec3O7u3mX/33Xf4/fffMW3aNEyZMkXfrkJuwHHm3voT+OMHOhWye5t5Wlqay7bu3bsHNHebNm2wZcsWZGZmomnTpvp+2psMtEsjqtafnnJrKroUpbv9zc7uPHONKv3pr5mb0Z9GZ65af/q6VjwJdH8aXSsq9uflzFyF/jQ6cxX783JmrkJ/2lu2bBmsViuKi4tdvk61/nTOXbVqVZfnO1+oOHONKv3pnPtyZ272609vM1etP43mroiZrz+9rRUV+9M5u5GZq9Cfzrk9zVzF/nSXvW/fvh7v22KxOPTnhg0bUFZWdlk5nf0pDiyEhIRgwIAB+OCDD5Ceno4WLVo43H769GmvP5zPmDED2dnZDtvS09PxzDPP4IknnkCHDh0QFRWFFi1aYN26dQ77LVy4EBs3bkSdOnUwZ84c/bqRTZo0AVB+BNdZdnY2Bg4caGpuABg9ejRycnKwbt06Pbc7ly5dwjPPPAMAesZAZfd2Xx9//DF69eqlH82LjY1FSkoKsrKycP78eURHR+v7FhcXY9CgQabn1r72lltu8fl6l2ZnB1xnDpQ/CZ8+fRo333wzli1b5vLvMju3u5lfvHjR7bVQ16xZA+CPdwmYnR1wnfmMGTMwZcoUpKenY+HChQ732bFjRzz++OOIiYlRLndeXp7Lu7nsi/vWW281fd7u1kp0dDR69+6Njz/+WH9XGgDs3bsXwB8HW83ODrh/fGo++OADAMBf/vIXhx/szM7tbuZafx46dMhhX+16lcnJyUpkB7zPXKO9q6hq1aoYOnRoQHMPHjwYzz//PN5991107dpV3/+dd95BaGgounTpAkC9/vSUG4BDbqNUyO48c0Ct/jQ6cxX70+jMVetPo7lV60+ja0XF/vTl8alRoT+NzlzF/rycmWvM7E/7+9y6dSsaNmzo8I5bjWr96Zx76NChCA29/F8JqThzQK3+dM7taeYq9qdzdk8zV60/jeZWrT+dc3taKyr2p3N2b49PjQr96Zzb08xV7E932SMjIz3etz3td7gpKSkYOnSooa/x6oovphQgV/IZCyIiJ0+elLp160pkZKRMmDBBFixYILNnz5ZBgwZJfHy8z3l8vc6y82csiIikpKQIAOnXr5+89dZb+vXFrFar7Nu3z9TcIp4/Y2HQoEHSrFkzqVatmrz00kvSrFkz/RqXZsz85ptvlt69e8uMGTNk4cKF0rJlSwEgsbGx8ttvvznse/vttwsAad26tbz11lvy9NNPC1D+ae5m537kkUf0a9E55/7ll1+kdevWEhcXJ02bNpW4uDiZPn26AOXX8DY7u6eZZ2RkiNVqFYvFIvPmzZOlS5fK0qVL9XX/yy+/mJrb08x37dol1apVk6ZNm0pCQoK88cYbMnLkSH3fxx9/XN9XtZmLuD4nOl/jUsXc27ZtE5vNJjExMTJv3jx5+eWXpVOnTgJArr32WtNze3t87tmzR0JDQyUkJERmz54ts2fP1p/fJ06caHp2I2slKSlJ2rdvLyLm9acvM+/Ro4cA5ddV1vozPj5eAMi4ceNMz+5t5nXr1pXo6GhZsGCB3qEAZPjw4QHPLSIyatQoASCDBw+Wm266Sb/25lNPPeWwn0r96Zx73rx50rBhQ7e5VetP5+yeZq5afzrn9jRzFfvTObu3da5SfxrNrVp/Ouf29vhUrT+dsxtZKyr0p3NubzNXrT+ds3ubuWr9KSIyd+5cASB9+vTx+LsK1frTPvemTZs8/p5Fxf60z+5p5ir2p31uTzNXtT/ts3tb56r1p5HcKvanfW5vj08V+9M+u5G1okp/2uf2NnMV+9M5uyeDBg3Ss9j/Dnfr1q0+53HnT3NgQaT8gzTGjRsntWvXFqvVKsnJydKtWzdZuHChz3n8cWBh2LBhEhcXJ82bN5eIiAj9A5HHjBljem4RzwcWXnjhBYmJiREAEh8fL3379pVdu3aZNvM5c+ZI27ZtJSEhQUJDQyUyMlIAyIEDB1zuY8SIEZKcnCwdO3YUm80miYmJAkAmTZpkeu6UlBRp0qSJ25kvWrRI/yHb+Y/zh62oNHPt6z39sV8vKs389OnTcv/990tMTIxYLBYJCwuTxo0byyOPPBI067yiH+xUy33w4EGpW7euhISEiM1mk8jISGnTpo0AkClTppie29vjU6T8RaPNZpOoqCiJjo6WO+64I2jWSo0aNQSAvP766yJiXn/6MvP8/Hxp1aqVWK1WvT+1F+4qZPc28zZt2khoaKjYbDa9Q838maWoqEimTp0qdevWlSpVqggA+cc//uGyn0r96ZzbarXqP0M5U60/nbN7mrlq/emc29PMVexP5+wVrXNV+tNobtX60zm3t8eniFr96Zy9orWiSn865/Y2c9X60zm7t5mr1p8iIu3bt5caNWrIgw8+6PV3FSr1p33ukpISj79nUbE/7bN7mrmK/Wmf29PMVe1P++wVrXOV+tNIbhX70z63t8eniHr9aZ+9orWiUn/a5/Y2cxX70zm7Jy+88IJcddVVDv25a9cun7N4YhHxcJEoIiIiIiIiIiIiIiIiJ75dxJ2IiIiIiIiIiIiIiP7UeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDAs1O4BqLBaLx9tEJIBJfBOsuYHgzR6suYHgzc7cgRes2YM1NxC82Zk78II1e7DmBoI3O3MHnsViQU0AnwNoCOC/ALoAOAa1swf7zD1ROTtzB16wZg/W3EDwZv/GYkEN/PH8rakF4KjCuYHgnTlzB16wZg/W3EBwZ3fGMxaIiIiIiIj8LBPlv4z6L8oPLmwH0MHEPERE5Jsa+OP5u9b/bav1f38nIiIeWCAiIiIiIqoUx+B4cOFrU9MQEZEvuuCP5++dVavi7gYNsP3//k5ERIBFgu0ci0oWrKejBGtuIHizB2tuIHizM3fgBWv2YM0NBG925g68YM0erLmB4M3O3IHnnL0D7A4qKJz9f2nm9lTOztyBF6zZgzU3ELzZLRYLagH43GJBA7uc/wXQUOHcQHDP3BPmrhzBmj1YcwPBnd0Zz1ggIiIiIiKqJLUALDU7BBERXZZjAIY5/aJvuDlRiIiUwwMLRERERERElUC7Frf2Ac4dTU1DRES+cndwmAeLiYjK8VJIRERERERE/nbsGNC5M3DwINCgAbB9O1C7ttmpiIjIqKNHgS5d/ngeX7oUGD68/O/8VRoREQ8sEBERERERERERERGRcbwUEhERERERERERERERGcYDC0REREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhv1PHFgYOXIk6tWr57DNYrFg6tSppuQxKlhzA8GbPVhzA8GbPVhzA8GbnbkDL1izM3fgBWv2YM0NBG/2YM0NBG925g68YM0erLmB4M3O3IEXrNmDNTcQvNmZO/CCNXuw5gaCO3tlUvbAgsViMfRn+/btAc927tw51KhRAxaLBatXr76i3IWFhbjhhhsQGRmJ5ORkAEBRUVHAc/uS/aWXXsKOHTtw/PhxhISEuDywAp3daO5NmzZh3759yMrKQkpKCqKjo9G6dWsAQFlZWcBz+5L93nvvxaeffoqjR4/CZrOhcePGeOSRRyols5Hsl/v41O4TAH777beA5/Yle6tWrbB48WIcPnzYYXtl8vfMZ82ahauuugo2mw0AsGzZMhw7dkzJ3CtWrPA47+eeew733XdfQHP7kv3f//43/vOf/+D48eOoWrUqkpKS0KtXL7/nNZrdl7VSVlaGc+fOoUGDBggPD0eDBg0AmPOcyP6sHOxP9qc/cvuSnf0Z2NzsT/9lV60/u3Tp4vb79+zZ02VfX7KfOnUKJ0+e1Ptz/Pjxfsvsa3Zfch8/fhxnzpxBixYtKq1D/Z07UP1ZGWslUP1ZGWvFXmX1Z2XMPFD9WZkzr8z+9HfuQPVnZayVQPVnZawVlfrzwoULPmXPzc1FVlYWqlatioSEBAwfPtxvmS8n+7PPPouePXsiISEBFosF77//vtv7/P777/Hggw+iTZs2sFqtfn9eCfXrvfnR0qVLHf6+ZMkSbNmyxWV7s2bN8Pbbb1faC1t3pkyZgvz8fLe3vfbaa5g8eTIiIiLQrVs37N69G3v37gUAtG7dGo8++qiee9y4cVixYgXy8/Px6quv4tixY5g5cyZWrlyJWbNmBTT30aNHERkZqeeOiorC5s2bcfz4cYfcALB+/XocPXoUbdq0qZQXWb5mNzpzm82G7777Dl27dkXPnj0RExODzZs34+eff8ZHH32EadOmBTS3LzNfvnw57rzzTjRt2hTx8fHYu3cv3n77bQCV94s0f61z+8ent/sMRG5fZv7mm2+iZs2amD59OqxWq769MsrDSHZfZv7mm2+iT58+mDlzJu677z5cc801GD16NMLCwpCbm4tatWopl7tt27ZYtGgRRMTtvG+55Ra/Zq4oty9rZeXKlfj2228xdOhQdOnSBefOncOCBQsAAJmZmX7PXVF2X9bKpUuXkJubi4EDB+K6667Dt99+i0OHDuHTTz8N+HPi9OnTMW3aNCQkJKBr167YuXMnDhw4AJvNhmnTpiElJUXPrVJ//vTTT7BarXpuEcH/+3//DwUFBXjxxRf13IB6/Wl05qr1py8zV60/fVnnKvWnLzNXrT99mblK/Wk0t2r96ctaUa0/fVkrgerPWrVqYfbs2Q7bUlNTXfZr3749vv/+e/Ts2RNJSUlYu3YtcnNz8fe//x1NmzbV9ystLcW///1vXHXVVRg7diyOHTuGl19+2W95fc2+dOlSzJs3T89+6NAh7N27F1WqVMHkyZP17M2aNUNycjKKi4sRGxvrdgYq5g5kf/p7rQSyP/29VgLVn/6eeSD7098zD1R/+jN3IPvT32slkP3p77WiUn9mZ2cDAKpVq4bExETs27cPaWlp2LNnj8vvnmNjY/Hll18iNTUVEyZMwIULF/T+LC0t9VtuX7JPmzYNderUQcuWLb2+6X7Dhg145513cM0116BBgwbYv3+/X/NCgsS4cePEl7gA5Nlnn/V7jt27d0toaKhMmzZNAMiqVascbp85c6YAkPT0dBH5I/c999wjACQnJ0fft1evXpKSkiK5ubkOuQHI5s2bTc1tn905d2ZmphQVFYmIyG233SZ169bVs6s889OnTzv8+zTav/HAgQOm5rbP7jxzd1avXi0AZMCAAX7NfTnZva1zT/c5aNAg03PbZ3fO3blzZ0lLS3P5HqqvcxGRF154QaxWq3z33XdBldsdABIWFiaXLl0yNbd9dvvcxcXFEhERIQMHDnT4+oMHDwoAadu2rV9zX052TzP//vvvBYA888wzDl+v/Rt/+eWXgObu3bu3xMfHS3Z2tkPuqlWrSv/+/R32Vak/nXOLiIwcOVIAuORWrT+Nzly1/vRl5u6Y2Z++rHNP92lGf/oyc9X605eZq9Sfl7NW7JnVn0bXior9aXTmgepPT48lZ999950AkJdeeknfNmbMGAEgHTp0cNjXXX++/fbbAkCGDRvml9xXkl2becOGDV2yu+tQfz8+/Z07UP1ZGWvFncroz8pYK5rK7M/KmHmg+rMyZh6I/qzMtWLP3/3p77USyP7098xV68+CggI5ceKEiIj88MMPAkC6du3q9nfPDzzwgERERMjhw4f1bVu2bBEAcvvtt/sl95VmX7Rokdt9T548Kfn5+SLi++/WjVD2Uki+cHedK3cyMzMxatQoJCUlITw8HGlpaXjvvfd8+l4TJkxAv379cOONN7q9PS8vDwCQlJTksD0lJQVVqlRBWFiYvt+mTZtw8eJFxMTEOOxrtVqxcuVKJXIDcMgNlB8pu++++4Ju5tWrV8dLL73kMbf2jl6zcwOuMwdc17n2/wsKChz2U2nm9rkruk8VZ56ZmYl69erhwoULXr+vSjMvKyvD1KlTYbVa0bZtW5SUlHh8l45KuQHXNX7ixAkA5e9s0E6nNTs34LhWiouLcenSJaSnpztk1065tn/3i9nZnWf+5ZdfAgDeffddt/fz4YcfBjT3l19+ie7du6NatWoO2zt37oxPPvlEfxyq1p/uckdFRQGAQ25Avf40OnPV+tOXmQNq9afRmdvnVqE/fZ25Sv1pdOaq9eflrBWNmf1pdK2o2J9GZx7o/iwpKfH6WFq9ejVCQkJw//3369tCQ8svTPDNN9/g6NGjAMr7c8uWLUhISMA111yj73vPPfcAAPbs2eNwv2ZlB4DRo0c7ZAeAyZMno3HjxhV+T5VyB7o//bVWNIHsT3+ulUD2p79nHsj+9NfMA92flbFWNJXZn/5aK2b0p79mrlp/hoeH65fUrciaNWtQo0YN3HTTTfq27t27AzCnP33JnpSUhIiICJ++vy+UvRSSv2VlZaF9+/awWCx46KGHkJiYiI0bN2L06NHIy8szdL3AVatW4euvv8bevXuRkZHhdp8uXbrghRdewOjRo/Hcc8/pC+Gtt97C+PHj9R+sd+/eDRFBeHi4y30kJydj165dpuauVq0aDhw4AAAOuX2h2swrUr16dVNzG5l5WVkZTp48iQMHDmDSpEkA4FAmqs48Pz/f632qOvPc3FycO3cO0dHRSEpKcnudRdVm/ttvv+HSpUuIi4vD/fffj8WLF+unKx86dEjZ3O6sWLECABxe/Kq2ViIiItCuXTv8+OOPiIuLw5EjR3Du3DlMnz4dANCmTRvTs3uaeWFhIQB4vMbijz/+GNDchYWFbn/giYyMRFFREdLT09G+fXvl+tNTbgAOuX1hdnbnmVck0P15OTNXpT99nbkq/enrzFXqT6MzV60/r+TxaWZ/Gl0rKvan0ZkHsj/379+PqKgoFBUV6Y+lKVOmOPziaNeuXWjSpInLwXbNzz//jNq1a2P37t0oKSlB9erVHX5Zob3hQPuFmgrZ27Zt65DdqGDL7c/+9OdasReI/qyMmQeiPytj5oHqT3/OPJD9WdmPz8rqT3+ulUD3pz9nrlp/GpWZmYlTp06hTZs2+uWT7JnRn0rx6/kPlcjb6RojRozQLyeggdNpV6NHj5aUlBSH03JFRIYMGSKxsbH6aSGe5OfnS506deSpp54SEZFt27a5PYVWRGT69OkSERGhn84DQJ5++mmHfVatWiUAJDk52SV38+bN9e1m565o5t4u5WB2dueZ2+fWFBYWCgCJi4uT4uJiJXJ7mvngwYMd9qlVq1ZQzHzYsGESEhLicp/2p6KandvdzEeNGiUtW7aUxMREWbJkifTt21ffV+WZr127VgBIlSpVpHHjxrJo0SJZtGiRvk07vVC13CKuj882bdoIAJkyZYq+zezc7tbKgQMHJCEhwWGfBg0aKL9W1qxZIwCkevXqDtu1/Vu0aBHQ3FdffbU0adJESkpKROSP3q9Tp44AkNWrV4uIev3pnFtEZOzYsfoctdwalfrT6Mztc2vM7E9fZ65Sf/oyc5X605eZq9afRmeuWn9eyePTzP70Za2o1p9GZx6o/hw1apRMnTpV1qxZ4/BYGjx4sMN+aWlp0rVrV4dt9pdvnD9/voj80Z89e/Z0+9o5KipK/7tZ2bXce/bsccgu4rjOPV0KSfXcIpXTn/5eK5pA9GdlzDwQ/VkZMw9Uf/p75oHqz0A8PiujPytjrQSqP/09c9X60563SyFpt91www1u+xOAFBQUmJ7d06WQ7PFSSJdJRLBmzRr06dMHIoLs7Gz9z6233orc3Fz89NNPXu/j+eefR3FxMSZPnlzh96tXrx5uuukmLFy4UP/k7lmzZuGNN97Q97l06RIA90fqQkNDcenSJVNzr1mzBs2aNQMAh9xGqThzdx566CEAQO/evREaGqr0zMPDw5GUlIT169dj2rRp+jtcNKrOfPfu3QDg8T5Vnfm7776LVq1aITIyEsOHD8dHH32kv2NE+9BVFWduf0mHzz77DCNHjsTIkSP121988UUlczvbv3+//o4F7XlS1bUSHR2NuLg4REdHY+3atXjzzTdRUlICAPppwCrOvHfv3oiKikJOTg7Wrl2Lw4cP65cRslgsAe+hBx98EPv378fo0aPx22+/4cyZMwD+eAeI1puq9adz7vT0dGzdulW/XctrlIozd8fM/vR15ir1py8zV6k/fZm5av1pdOaq9eflPj7N7k9f1opq/Wl05oHqz3fffRfPPvss+vfv7/BY0j60036m7s7is7/d/n9DQkLc7qfNXoXs2iVIfOnQYMldGf3p77WiCUR/VsbMA9GflTHzQPWnv2ceqP6s7MdnZfVnZayVQPWnv2euWn8aVVF/avuomD0grvzYRGBcyRkLWVlZLu84df6zdu1aj9/70KFDEhERIe+9956+zdM7XZYvXy4RERFy9OhRh9wjR46UyMhI/aiVkXdcmpnbPrt9bk1F77hUceb2uUVEXnzxRZd3AATDzDU7duwQADJ06FDTs3ua+aFDhyQkJESqVavmcp/aO0aCaeb79u0TAHLzzTebnr2i5xabzebw9QCkXr16Ur9+fSVzO897ypQpQfH4LC4ulhYtWshVV13lsFb2798vAKRjx46mZ/c28zvuuEOsVqueITw8XP83tmzZMqC5RUQmT57skAcoP9MCgKxbt05E1OtPd7kTExP1/6/l1qjUn0Znbp9bxPz+vNyZa8zsT3fZ3c1ctf680pmb2Z9GZ65afxrN7Txvs/vTXW53a0XF/vRl5pXdn55oj6Xp06fr2/x9xoKZ2a/kjIVgyF0Z/Xklue2zO+d2zi7i//68kuyeZh6I/ryS3PbZjczc3/15Jdk9zTwQ/VkZuUUqvz+vJLd9dvvcgerPK8nubeYq9ac9f5yxYHZ2s85Y+FN8xkJZWRkAYNiwYRgxYoTbfeyvoeZsypQpqFmzJrp06aJfn+/kyZMAgNOnTyMjIwN16tRBlSpV8Oabb6J169aoVauWw3307dsX77//Pnbt2oXu3bsjJSUFAFBaWury/c6fP4/U1FQlcgPlRzy13EapkN155vbef/99PPnkkxg7dizmz5+vVG7A2Mw7duwIAPj111+Vye488ylTpiAyMhI2m83lPi9evIiMjAz9uq7BMHPtWozaEWsVZ56amgqg/AOGnUVFRSEzM1PJ3M4++OADNG3aFP/5z3/0bSrkBhzXyhdffIH09HT06NED+/fv1/fRPlzQ/kPNzM7ubuZxcXFITU3Fp59+irNnz6J58+aoVq0a8vPz0aRJk4DmBoCZM2fisccew549ezBv3jysWLFCz9CkSRMAUK4/nXPHxsZiwYIFmDdvnkNuo1ScuT0V+tM5t68zN7M/nbN7mrlq/emc29eZm9mfztk9zVy1/jSa25nZ/emc29NaUbE/nbN7m3ll96cn2mMpJydH35aSkoLMzEyPX6Otba0/Pb1bNzo6GsCVz9wTX7JrZ4lo2Y1QPXdl9ac/cmsqmre/+9OTK5l5IPrTH7k1Fc3c3/1Z0fe5nJkHoj8rI7ezyuhPf+TWaLkD1Z/+yO5u5ir1p1EV9afNZkN4eLiS2QPhT3FgITExEdHR0SgtLfXpl+OaI0eO4Pfff0eDBg1cbnvwwQcBAGfPnkVcXByysrIQHx/vsl9xcTGAP04xbdGiBSwWi/7hJfZOnjyJHj16KJFbo+U2SoXszjPX5Ofn495770X//v0xb948hx/sVMitMTpzbQ2pkN155keOHMH58+dx/vx51K9f32HfDRs2oH79+sjOzjY9t6aimR88eBBA+Yf4AWrO/Oqrr4bFYvH4S9fExEQlc9v77rvv8Pvvv2PatGmYMmWKvl2F3Botd1ZWFgBARNzup/1woUJ2bzNPS0tz2da9e/eA5tbEx8fjhhtu0D88bevWrahVqxauuuoqAOr1p3Nue/a5jVJx5hpV+tM5tz1fZm5Gfzpn9zRz1frTObc9IzM3sz+ds3uauWr9aTS3PRX60zm3PfvcKvanc3YjM6+s/vREeywlJibq21q1aoVt27YhLy/P7Yd+tmrVCkB5f4aGhrp88KT2IavJycn6fZud/bvvvnPIboTKuSuzP/2R2/52I/zVn55cycwD0Z/+yG1/u5H79Fd/VvR9LmfmgejPyshtr7L60x+57W8HAtef/sjubeYq9KdRNWvWRGJiotsPbgbM6U+V/Ck+YyEkJAQDBgzAmjVrkJ6e7nL76dOnvX79jBkzsG7dOoc/2ieuP/HEE1i3bh2ioqIAlL+TZdeuXQ5HDgFg+fLlqFKlin50KjY2FikpKbh48SLOnz/vsG9xcTEGDRqkRG4ADrmNUiG788yB8ifh06dP46abbsKyZctcjqqrkBtwnPnFixf16+TZW7NmDYA/jv6qkN155jNmzMDNN9+MxMREl/vs2LEj1q1bh5iYGNNzA44zz8vLc/mlpYhgxowZAIBGjRoBUHPm0dHRqFWrFgoLC7Fv3z6HfY8ePYoePXoomdveBx98AAD4y1/+4rBdhdyA41rR3r146NAhh320aydqP2SokN3bzDXauzCqVq2KoUOHBjS3Jz/88AMeeeQR/flatf5058CBAwDgkNsos7MDrjMH1OpPd9zNXMX+9MR55qr1pzvuZq5if3riPHPV+tNobnsq9Kc77taKiv3pibeZa/zdnxU9lm699VZ9+8CBA1FaWoqFCxfq27Rf8LVr105/p2NsbCy6d++OgwcPOvxCaunSpQD++CWP2dkBYNGiRQ7ZjVA1d2X3Z2WslUD1Z2XMPBD9WRkzD1R/VsbMA9Gflf28Uln9WRlrJVD9GajncjP70xcDBgzAsWPHHA6gffbZZwDM6U+l+PXCSpXoSj5jQUTk5MmTUrduXYmMjJQJEybIggULZPbs2TJo0CCJj4/3OY+na3N+/vnnEhISIjVq1JBp06bJTTfdpF9L695773XY9/bbbxcA0rp1a3nrrbf063c2aNDA9Nzz5s2TOnXquM39yy+/SOvWrSUuLk6aNm0qcXFxMn36dAEgQ4YMMT27p5lnZGSI1WoVi8Ui8+bNk6VLl8rSpUsFgPTr109++eUXU3N7mvmuXbukWrVq0rRpU0lISJA33nhDRo4cKaGhoQJAHn/8cX1f1WYu4vr4dL7GpZm5Pc1827ZtkpycLM2bN5eEhAR5+eWXpVOnTi7XXDQzu7eZ33HHHWKxWCQlJUVmz54ts2fP1q9beOzYMWVza2slKSlJ2rdvLyLqPJd7e07s0aOHPt+33npLpkyZIvHx8QJAxo0bZ3p2bzOvW7euREdHy4IFC+Sll16SZs2aCQAZPny4Kbm7desmL7zwgrzzzjvSvHlzAcqvBV1cXOywr2r9aZ/73nvvFYvFIgBccqvYn0ZmrmJ/Gpm5qv1pdJ2r1p9GZq5qfxqduWr96etaUaU/jT4nqtifRmde2f2pPZYmTpwo8+bNc3gs3X///S77Dxo0SEJDQ+Xxxx+XBQsWSHJysgCQzz//3GG/H3/8UapUqSJhYWF6f9psNr+ulyvJ3qVLFwEgoaGhLtn79u2r96bWoUD5tec//vhjJXMHoj8rY60Eqj8ra61Udn9WxswD1Z+VNfPK7s/KXiuV1Z+V9VweiP6srJmr1p9z586V6dOnywMPPKC/ngTKP8/g3Llz+n5HjhyR8PBwCQ0Nlddff11mzZqlz/zpp59WInv//v1l+vTpLtkzMjL07e3atdP/fdOnT5clS5Z4zWTEn+bAgkj5h5eMGzdOateuLVarVZKTk6Vbt26ycOFCn/N4+9Cv7777Tnr16iXJyclSpUoVASAzZ850+yIgOTlZOnbsKDabTf9gs0mTJpme22q1SmxsrNsXAYsWLdILzvlPy5YtTc/uaeba13v6Y79eVJr56dOn5f7775eYmBixWCwSFhYmjRs3lkceeSRo1nlFP9iZldvTzA8ePCiDBg2SqKgovbDbtGkj8+fPD5qZp6SkSPfu3SUqKkqio6MFgDz00EPK565Ro4YAkNdff11E1Hku9/acmJ+fL61atRKr1SoRERESGxur/+JbhezeZt6mTRsJDQ0Vm80m8fHx0rdvX9Ny//7773LLLbdI9erVJTw8XP+FQWFhoct9qNSfzrmvuuoqad++vdufWVTrT6MzV60/jc5cxf70dZ2r0p9GZ65if/o6c1X609fcqvSnL8+JqvWnLzOv7P7UHkv16tUTm83m8FgqKytz2f/SpUvy2GOPSXJysoSHh+vrwZ2ePXtKeHi43p/a62wVsms/s2zatMllP/tfsjr/GTFihJK5A9GflbFWAtWflbVWKrs/K2PmgerPypx5ZfZnZeauzP6srOfyQPRnZc1ctf6sW7eux+foQ4cOOex7xx136PcZFxcnd999d1Bk99ZFnTt39prJCIuIhwtzEREREREREREREREROflTfMYCERERERERERERERH5Bw8sEBERERERERERERGRYTywQEREREREREREREREhvHAAhERERERERERERERGcYDC0REREREREREREREZBgPLBARERERERERERERkWGhZgdQjcVi8XibiAQwiW+CNTcQvNmDNTcQvNmZO/CCNXuw5gaCNztzB16wZg/W3EDwZmfuwAvW7MGaGwje7MwdeMGaPVhzA8GbPVhzA8GbnbkDL1iz/9diQUMA/wXQBcAxALUAbAfQUOHcQPDO3B2esUBEREREREREREREQaELyg8qNET5wYQO//e/DU1L9OfEAwtEREREREREREREFBSOwfHgwtf/978HTcz0Z8QDC0REREREREREREQUNI4BGO60bXRYmBlR/rR4YIGIiIiIiIiIiIiIgkYtAEudtr1TVGRGlD8tHlggIiIiIiIiIiIioqCgf1Azyi+H1BF/XBaJAocHFoiIiIiIiIiIiIgoKGzHHwcVugD4Bn985gIFjkVExOwQREREREREREREREQV6tABOHUK2L4dqF37j+1Hjzr+nSoVDywQEREREREREREREZFhvBQSEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhvHAAhERERERERERERERGcYDC0REREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG/U8cWBg5ciTq1avnsM1isWDq1Kmm5DEqWHMDwZs9WHMDwZuduQMvWLMHa24geLMzd+AFa/ZgzQ0Eb/ZgzQ0Eb3bmDrxgzc7cgRes2YM1NxC82YM1NxC82Zk78II1e7DmBoI7e2VS9sCCxWIx9Gf79u0BydOlSxe3379nz56Xlfvf//43fv/9d5w6dQq1a9dGVFQUWrRoAQAoKSkJeO4LFy4Yzv7YY49h06ZNOHr0KMLDw1G/fn389a9/9VtmX7Nf7lopLi5G8+bNAQBff/11wHP7MvOePXti8eLFOHz4sMN2f6vMmb/11lto1aoVIiIiAACLFy/GL7/8omxuT/N+7rnn0KNHj4Dm9mWtbN++HRkZGThx4gTi4uJQrVo1dO7c2S95Lye7r2vl/PnzaNasGcLDw1GzZk0AQFFRUcBz//DDDz5lz83NRVZWFqpWrYqEhAQMHz7cb5l9ze5L7uzsbOTk5KBNmzawWq1B8byiWn/6slbYn/7J7cvM2Z/+ye3LzC0Wi8eZL1myxC+5fcnu68zz8/PRvn17vUMBYP/+/crnVqU/9+zZ41N29mfgcqvWn76sFfanf3L7MnP2p39y+zJzi4X9aUZuVfrT1+ynTp3CyZMnERkZieTkZIwfP95vmX3N7kvu48eP48yZM2jRogVCQkJcflEfyNy+ZJ8wYQL+9a9/4ejRo4iOjkbr1q3x1ltvmZrd3syZM2GxWPRetzdr1iy0b98eiYmJsNlsaNy4MR555BGcPn3aL5lD/XIvlWDp0qUOf1+yZAm2bNnisr1Zs2Z4++23UVZWVumZatWqhdmzZztsS01Ndfj7q6++ikcffRTVqlVDYmIi9u3bB8D131OvXj3s2LEDbdu2Rd++fVGjRg1888032LNnD/75z39i+vTpfituI7mzs7MBwCF3Wloa9uzZ45J969atuOWWW5CWlobExEQcOnQIb7/9NoDyJ2V/8ufMndfK3LlzceTIEb/m9SW3LzNfv349wsLCMH/+fFitVn17Zbz4qoyZjxo1CuPHj8c999yDhx56CPfddx9iY2Nx6tQpZXMvWrQIIuJ23rfccktAc/uyVnbs2IHPP/8cPXv2xB133IGCggK8//77AIC9e/f6LbfR7L7MvHr16sjJyUHXrl0xYcIE/Pbbb5g7dy4+/PBDzJo1K6C5X3jhBcTGxqJt27aoU6cOzp07h/Xr16OoqAizZs1C7dq19X1jY2Px5ZdfIjU1FRMmTMCFCxfw8ssvAwBKS0v9ltto9uuvvx779+/Xs2/fvh3//e9/ER4ejmeffVbP3qxZM7Ru3RqbN2+GxWJBgwYN/PrDf2XlVq0/fVkrqvWnL2tFpf70Zeaq9aevM1elP32ZeW5uLqKiohw6dOfOnZgzZw4aNmzot9xGs/sy81atWmHx4sVo27Ytnn/+eRQUFGDixIlYvnw5Bg4ciP79+yuZW6X+PHz4MK6++mo0atQI8fHxKCoqwieffIJz587hr3/9K7p27arvq1p//u1vf8O//vUvPfuOHTvwn//8BwAcsqvWn0Zzq9afvqwV1frTl7WiUn/6MnPV+tPXmavSn77MXLX+9GXmKvWnL7lV6k/gj9fIOTk5ePzxx1FSUoKysjKX186lpaX497//jauuugpjx47FsWPH9P70NyPZ7fPl5ORg4sSJKCsrQ82aNfH888/rtzVr1gzJyckoLi5GbGys2xkEMrd9dm8zP3r0KCZPnoyuXbvi4YcfRkJCAjZv3owHH3zQ1OyaY8eOYdasWYiKinJ7+48//ohWrVphyJAhiI6Oxt69e/H222/j008/xc8//+zx6wyTIDFu3DjxJS4AefbZZ/32/Tt37ixpaWkV7ldQUCAnTpwQEZEffvhBALjNXVhYKDt27HDZru2/ZcuWKw8tV5a7a9euhme+c+dOASDdunW7orz2/D1ze1lZWRIbGyvTpk0TANKjRw+/ZBapnJmPGDFCoqKiXLarvs5FRD788EMBIGvXrtW3BUNud7T9jx49etlZ7VXGWmncuLFcf/31UlZWpm/Lzc0VANKkSRO/5L7S7O5yHz9+XEJDQ2X48OEO27X9P/7444Dm3rFjhxQWFjpsu/vuuwWA3H333Q7bH3jgAYmIiJDDhw/r27Zs2SIA5Pbbb/dLbpHLz671Z3h4uEv2kydPSn5+vsN+Zj0+jeZWrT99WSvumNmfvqwVjQr96cvMVetPX2auUn9e6TofPXq0AJCJEydedlZnlTFzdx0KQKxWq/Tt21fJ3Kr1pzsPPvigAJCmTZs6bFetP51pM2/ZsqVLdpX605mn3Kr1pzue1oo7ZvanM29rRaNCf7rjaeaq9aczbzNXqT/d8WWdm9mfzrzNXKX+dOYpt8r9edddd0nXrl0lNTXV7WvnXr16SUpKiuTm5urb3n77bQEgw4YNu+LMmsvNXrNmTQHg9mszMzOlqKhIRERuu+02qVu3rhKPT28zP336tKSnp7t8zV//+lcBIA8//PAV5bV3Jdl9+drVq1cLAFm+fPnlxHSg7KWQfOHuOlfuZGZmYtSoUUhKSkJ4eDjS0tLw3nvv+fS9SkpKcOHCBY+3h4eHIzk5ucL7CQsLw8KFCz3mtn9nsUq5Nc4z1/5/QUGBw36qZddyT5o0CU2bNsWwYcPc7qdabgAoLCxEvXr1kJeX53U/1bKPGzcOYWFh6NevH8rKynDx4sWgyO28xgsLCwEAdevWRa1atZTNnZeXhxMnTqB+/fr6tpiYGABweLeRatm/+eYblJSUYPPmzW5vX7FiRUBzd+zYEWFhYQ7b4uLiALie+bFmzRrUqFEDN910k76te/fuAMpPf7ZnVnYASEtLc8n+5JNPolmzZhV+T5Vyq9afvqwVQK3+9GWtqNSfvs5cpf70ZeYq9eeVrPPCwkKsWbMGwB99ZHZ2wP3Mjx49ivT0dJd3bYeFhemX0lAtt2r96Y42z3PnzjlsV60/Paldu7ZLdpX60xPn3Kr1pzue1gqgVn964m6tqNSf7nibuUr96Ym7mavUn+4YXedm96cn7mauUn8aza1qf37xxRdYvXo1XnvtNbe35+XlYcuWLUhISMA111yjb7/nnnsAmNufWvYbb7zR4z6TJ09G48aNK7wvlWZevXp1pKWlufRQv379AMDlkkIqZfdE+3e4ex7ylbKXQvK3rKwstG/fHhaLBQ899BASExOxceNGjB49Gnl5eXjkkUcqvI/9+/cjKioKRUVFSEpKwn333YcpU6a4/LLOH6pXr6587rKyMpw6dQpHjhzBtGnTAMDhl5mqZi8qKsLixYvx1VdfuT3dV9XcJSUlOHLkCGJjYxEfH4+hQ4cqnz0vLw/Z2dmIjo7G5MmTMXfuXP3J0b7wVMvtzoYNGwDAobxVzN2lSxesXLkS8fHxyMjIQEFBAebOnQsAaNeunbLZtQM3nk7B//HHH03PLSIA/nh+Bsp/aDh16hTatGmjX7LK3okTJ/T/b/bMs7KykJaWVuF+7r4umHKr0J/u1oo91fvT08xV7k9vMw+G/nSeeTD0Z0XrXLNhwwa3L1pUmzkAJCcnIyMjA3PnzkWfPn30X1gWFhZiwoQJSuZWtT8vXryIS5cuITc3Fz///DMAoFu3bvrtKvenfXYA2LhxI+66664Kv4ezYMttVn9WtFbsqdafRmeuWn8anbmK/VnRzFXtT1/WuUaV/jSyzlXsz4pyq9ifpaWlePjhh3Hvvffi6quvdntfu3fvRklJCapXr+7wi2ftzQhm9ad99tDQK/tVs2oz9+TkyZMAgMjISOWziwjOnDmDkpISHDhwAJMmTUJISAi6dOni07/Z050HBW+XQhoxYoTUrVvXYRucTqUZPXq0pKSkSHZ2tsN+Q4YMkdjYWP1UVk9GjRolU6dOlTVr1siSJUukb9++AkAGDx7s8WsqutSKp9xhYWFy9uxZ03N7uxTSiBEj9H8bAKlWrVrQzDwsLEyGDh0qIiKHDh1yORVVxZlPmjRJWrRoIYmJibJ8+XKH+T/zzDNKZHeX+6effhIAUqVKFUlKSpI333xTli1bpu+/ceNGJXOLuD4+BwwYIADkySef1LepuFaysrIkJSXF4fFZvXp15R+fP/74owCQuLg4h+3a/lWrVjUtt6Z79+4CQN59912Xf9MNN9zg9vkcgBQUFJia3f4SDfbZRRzXuadLOaieW6NCf2rcrRX77Cr2p0jFM1exPzWeZq5yf4p4nrnK/ampaJ1rj9EBAwZIeHh4UKzzu+66S2w2m8NjFICMGjVK2dyq9ueYMWNc5piTk6PfrnJ/OmcfOHCgQ3YRNfvT19was/uzorVin121/jQ6c9X608jMVe3Pimauan/6ss5V608j61zF/qwot4r9+cYbb0hsbKycOnVKRMTtZXlWrVolAKRnz55un8/tL2FmVnatF91dlsd+jXu6FJJqM3eXvbCwUJo3b27qc6Jzdm+XQjpx4oTD46FWrVry4Ycfes1i1J/iwEJZWZnExcXJ/fffL6dPn3b4s2jRIgEgX331lc+Z7rvvPgEg33zzjdvbff3F5cyZMwWA9O7dW4ncFR1YSEpKkg0bNsgrr7wirVu3DoqZd+rUSSwWixw5ckREXH+wMzt3RTN3t14GDBigRHZ3ub/44gv9tm+//VbfDkAiIiKkU6dOSuYWcZx3bm6u/oOSKmvc01o5f/68NG3aVKKiomTVqlXy3nvvydVXXy3AH9f+Mzu7p5lXr15dLBaLvPfee3Lo0CHZsGGD/sIgJCTEtNwiInv37hWr1SoApKSkRN+urfHOnTt7/MXI2bNnTc3+l7/8RQBIhw4dHLKLVPyLkWDILaJOf4p4Xiv22VXsTxHvM1e1P0WMzVzF/hTxPHOV+1PE+My1/uzXr19QrPO//OUvEh0dLSNGjNA7VHuRfuDAAWVzq9ife/fulS1btsjixYv1XxqcPHlSv13l/tSyd+vWTQBIv379HLKLqNmfvuYWUaM/K1or9tlV608jM1exP32ZuWr9WdHMVe1PX2euUn8aWecq9qeR3Cr1Z3Z2tiQkJMjLL7+sb3P3S+4lS5YIAP2X8vaA8s9iEgnsWnHOfiUHFlScubvs2v2plN3bgYXCwkLZsmWLrF+/XqZNmyatWrVy++agy/GnOLCQlZWl/wf39Mf+g32M2rdvnwCQ6dOnu73dl19crlixQiwWi1K5ffkl9++//y4ApFevXkpkd5dbK+fY2Fh9m/MPdmbn9mXm+fn5AkBat26tRHZ3ubXbQkNDHbYDkFatWonVapXMzEzlcos4zlv7wSgYHp89e/aUWrVqOayVM2fOCABp3ry5Etk9zXzQoEH6u3IASEhIiACQ1NRUiY2NNS33iRMnpEGDBlK1alWX7EbfcWlm9piYGAEgmZmZLrdX9IuRYMitUn96Wyvusouo05/eZq5yf17OzFXpT28zV7k/fZm51p/aB8Sp8Bj19tySmpoqERERDtsAiM1mk8GDByubW9X+1Gj9Yv/Bnqr3p33uHj16uHwoqar96UtulfrTObtzbufsIur0p31u55mr3J/O2Y3MXJX+tM/tPHOV+9M5u7eZq9af9rndPbeo2p8V5VapP8eOHSuNGjWSwsJCfduVnLFgZvYrObCg4syds7/44ov6famU3ZcPb96xY4cAkPXr1/ucx9mf4jMWysrKAADDhg3DiBEj3O5jf910o2rXrg0AyMnJufxwALZs2YJ77rkHt912Gz755BN9u+q57TVs2BAA8OuvvwJQM/vLL7+MsrIyREVFISMjAwBw7NgxAMClS5eQkZGBKlWqKJfbE+1DkC5dugRAzZmnpqYCgD5Xe1FRUSguLtavC6hSbmfLli1DbGysfn1GQM15Hzx4EJs2bUKHDh1w/PhxfXtCQgKA8g/VAtTMDpRfmzA5ORlbtmzByZMn0bhxY6SkpCAvLw/NmjUzJXdubi569eqFc+fOoU+fPli+fLnD7SkpKQD+eBw6s9lsCA8PNzW7dv1Q7fHoC9Vzq9SfFa0VT1Toz4pmrmp/Xu7MVejPimauan/6OnOtP2+//XaH7SrO/ODBgzh+/DiqVavm8rV16tTBjh07lMwNqNmf7vzwww/Yv38/mjZtqnR/Ohs4cCDGjBmjZzdC9dwq9ac79mvFExX605nzzFXtT3eMzFyF/nTmPHNV+9MdbzNXqT+dOc9c1f6sKDegTn8eOHAACxcuxGuvvebwOr60tBQAkJGRgZiYGCQkJFTYn9HR0QACt1bcZdc+8L24uNghuxEqztzehQsX8OSTT2Ls2LH4+9//jmeeeUaZ7AUFBYZn3rFjR6SkpGDZsmUuzzO++lMcWEhMTER0dDRKS0vRvXt3v93vwYMH9fu/XIWFhejXrx+uu+46rFy50uFDP1TO7Yn2okfF7EeOHEFRURGOHz/u8CFfAPDVV1+hfv362Llzp3K5PTl//jyAPz4oRsWZp6amwmazobi42OW28+fPw2azoX79+srltnfixAls27YNI0eOxHvvvadvV3HeWVlZAKB/oKYzrehUzG6vcePGaNy4sf73CxcuoHv37gHPXVBQgD59+mD//v3YunUrli1b5vK1NWvWRGJiotsPngTKP8hMu2+zst9+++1Ys2bNZd2/yrlV6k8ja6UiZvWnkZmr2J9XMnOz+9PIzFXsT19nXlpaqvdneHi4w20qztxbh5aVlaGkpETJ3PZU6U9vtDdpqNqf7mi/vLF/g0lFVM6tUn96Y3TeKr3+dJ65iv3pTUUzN7s/3XGeuYr96Y27mavUn+44z1zF/nTH23O52f2ZmZmJsrIyjB8/HuPHj3fZv379+pgwYQJee+01tGjRAqGhoS79WVRUBCDw/ekt+/79+x2yG6FCbgBucx85cgRnzpzBgAEDMG/evKDK7k5BQYFPP9t44noY939QSEgIBgwYgDVr1iA9Pd3l9tOnT3v9+ry8PP0HFo2IYMaMGQCAW2+99bJy5ebm4tSpU6hXrx4++eQT/R0AKucuKSnB2bNnXbZ///33AP54F5WK2cePH4+bb74ZiYmJWLduHdatW4cFCxYAAFq2bIl169ahUaNGyuUuKCjQf4izN336dABAo0aNAKg5c6D8Sa20tBRbtmxx2L5v3z507doVVqtVydyaFStWoKysDHfffbfDdhXn3ahRI1SpUgWHDh1y2K69M0r7IUPF7O5oB0JCQ0MxduzYgOYuLS3FXXfdhW+++QarVq1Chw4dPN7vgAEDcOzYMf3dDQDw2WefAQDS0tIABHbmztm1/+6XQ9XcKvWn0bWiYn8anblq/Wl05ir2py/rXKX+9OU5UXPx4kW3/QmoOXNtPVy8eNHllyOHDx9G69atlcztjpn9eerUKY95IiIi0Lx5c327av3pLjsALFmyxCV7RVTNrVJ/Gl0rKvan0Zmr1p9GZ65if/qyzlXqT1+eEzWq9KfRmavWn1fyXG5Wf7Zo0UJ/jrD/o73jfN26dRg9ejQAIDY2Ft27d8fBgwcd5r106VIAge9Pd9l79eoFoPyMFfvsRqg4cwD44osv8Pnnn8Nms2HZsmVuz4oyO3taWprLzC9evIj8/HyX77VmzRqcPXsW1113nddMRvwpzlgAgOeffx7btm1Du3btcN9996F58+bIycnBTz/9hK1bt3o9deqnn37C0KFDMXToUDRq1AiXLl3CunXrsGPHDtx///249tprHfZ/4403cO7cOYdTUrSF8PDDDyM2Nhbnz5/Hv/71L5SVlWH48OH49NNP9X1//fVXfPPNN+jQoYOpubXTNWfMmKHnvnDhAmrXrq2fHrZgwQLs3r0bixYtAgDcdNNNys782muvRZ06dXDw4EHceeedDv/GGjVq6NtUm/nJkyfRunVrJCUl4fz583j99dexefNmbNiwAQBw1VVXKTtzALj66quxf/9+DBgwAI8++qi+vaysDLNmzVI2t2bZsmVITU1Fly5dXL63amslMTERo0aNwjvvvAObzYY33ngD58+fx5tvvgkAuPHGG5XI7mnm33//Pc6cOYO33noLxcXF+OCDDwAAt99+O+rUqRPQ3H/729/w8ccfo0+fPsjJycE///lP/Oc//wEA/POf/8SwYcP0fSdPnoxFixbh5MmTmDt3Li5cuICXXnoJANCqVauAz9w5u31uAA7ZL1y4gNzcXMyYMQM7d+7Ut3/xxRdYunQphg8frlxu1frT6FpRsT+Nzly1/jQ6cxX705fHp0r96ctzoubixYse+1PFmScmJqJx48Y4cOAAunXrhv79++u/WCspKcFTTz2lZG5Arf4cM2YM8vLycNNNN6FmzZo4efKkfsmsGTNmoGrVqvq+qvWnc3atF3/66Se88sorDtlV6k+juVXrT6NrRcX+NDpz1frT6MxV7E9fHp8q9acvz4kaVfrT6MxV609f1ooq/Vm9enX9+cDeuHHjAMDltpkzZ+L666/HyZMnMX/+fBw7dgyvvPIKgD8O9JiZfevWrQDKL8vkfNvZs2f1/vz999/1d8x/8cUXWL9+Pfr06aPczA8fPoy+ffvCYrEgMjISq1atcvga7awdM2cOQD9Dwf62AwcOoHv37rjrrrtw1VVXoUqVKti5cyf++c9/ol69epgwYYLHPIZd8ac0BMiVfHizJisrS8aNGye1a9cWq9UqycnJ0q1bN1m4cKHX733w4EEZNGiQ1KtXT2w2m0RGRkqbNm1k/vz5Lh+2IyL6h4+4+3Po0CER+eNDmzz9GTFihJK5CwsLZcKECRIfHy8Wi0WsVqvUrVtXRo8erfzMRVzXivOHZ6mY++zZszJs2DCJjo4Wi8Ui4eHhkpaWJrNmzQqamdesWVP69esnMTExEhERIQDk3nvvVT639sE9jz76qIio/7wiIlJcXCxt27YVq9UqVatWlapVq8rNN98cFNk7deokVqtVoqKiJDo6Wrp162Za7s6dO3t9jnZ2xx136PcZFxcnd999d1Bkv/XWWz3u17lzZyVzq9afRnOr2J++rBWV+tNobhX709eZq9Kfvj4n3nnnnQ79KWJeh/qSffjw4ZKQkCCtWrXSOxSA3HPPPUrnVqk/ly9fLt27d5ekpCQJDQ2V+Ph4qVWrltt1IqJWfzpn1z7Q86OPPnK5X5X602hu1frT6FpRsT99WSsq9afRmavYn77OXJX+9PU5UaX+9GXmKvWnL7lV6k93vH2QcM+ePSU8PFxsNpskJibqvzNVIbu3D2/u1KmTMj3kjruZb9u2zWt/2ve+mdndfXjz6dOn5f7775errrpKoqKiJCwsTBo3biyPPPKInD59usL7NMIi4uFi3ERERERERERERERERE7+FJ+xQERERERERERERERE/sEDC0REREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGRYqNkBVGOxWDzeJiIBTOKbYM0NBG/2YM0NBG925g68YM0erLmB4M3O3IEXrNmDNTcQvNmZO/CCNXuw5gaCNztzB16wZg/W3EDwZg/W3EDwZmfuwAvW7MGaGwju7M54xgIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZZpFg+7hpIiIiIiIiIiIiIiIyDc9YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDOOBBSIiIiIiIiIiIiIiMowHFoiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsN4YIGIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLDeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw/4nDiyMHDkS9erVc9hmsVgwdepUU/IYFay5geDNHqy5geDNHqy5geDNztyBF6zZgzU3ELzZmTvwgjV7sOYGgjc7cwdesGYP1txA8GZn7sAL1uzBmhsI3uzMHXjBmj1YcwPBnb0yKXtgwWKxGPqzffv2gOTp0qWL2+/fs2dPv+Q+d+4catSoAQD47bffAp7bl+ytWrXC4sWLcfjwYYft/laZM581axauuuoq2Gw2AMCyZctw7NixgOb2JbvFYvE4848//tgvuX3J7svMRQTnz59Hq1atULVqVSQlJQEAjh49GvDcvmTfunUrfv75Z2RmZiI8PBwNGjTAjBkz/JbZ1+y+rvPCwkLccMMNiIyMRHJyMgCgqKhI6dzHjx/HmTNn0KJFC4SEhLiUdiBzb9++3XD2CRMm4F//+heOHj2K6OhotG7dGm+99ZZp2X2Z+a+//ooTJ04gMTERNpsNjRs3BgBcvHgx4Ll9mbn987nWn9pzoj9Vxsw3bdrk9rn8n//8p9K5NSr0py9rxWJhf/ojty8zZ38GPrdK/elLdvanf3L7ml3D/gxMbo0K/elLdouF/emP3L5kZ38GPrdK/Tly5EjD2dmf/snty8xV68+KsmdmZvp8n5cr1C/3UgmWLl3q8PclS5Zgy5YtLtubNWuGt99+G2VlZZWeqVatWpg9e7bDttTUVIe/2+fLycnBxIkTUVZWhpo1a+L555/Xb3POPWXKFOTn55uW2z57Tk4OHn/8cZT8f/buPD6q+v4e/5kkkz0kgYQs7GEnrEWB4sYugqJBsCggKLJUFNBWbVGRsopLK0VWqyh8EVGBVtQPFH7FBVCsisoqKARCWAxCQiAhJOT1+yO9l1nuJPdmmfsePc/Hg0fLnZub44v3zJnMzdwpKUFpaanXzBctWoR69eph5syZcDqd+vaRI0fakt3KzBctWoTbbrsNs2fPxtixY9G+fXuMGTMGoaGhyMvLQ/369f2W2zV7eTMvKirCpUuXEBUVBRHRZ75x40asWrUKTZs2rZbMVrJbmXl8fDzOnj2LAQMG4MEHH0Rubi6eeOIJLF++HOPHj0eXLl38lts1e0XrfMGCBfj2228xevRodO3aFZ9//jmefvrpaslamexTp07FnDlz0K9fP6SlpWHbtm3Ys2cPJkyYgPbt2yMmJgZA2cwnTpyIt956CwUFBfjrX/+K48ePY/bs2Xj77bcxZ84cZXMnJyejuLgYsbGxhv92/syt0XID0LMvWrRIz52VlYWpU6eiV69eePjhh1G7dm1s2rQJDz74oG3Zrcy8UaNG6Ny5M9LT0xETE4P9+/fjxRdfxKuvvorp06cjKirKb7k1Fc1cy6516GOPPVZj/Wk2u5WZt2jRAiEhIW6PlSNHjsR1112ndG7V+hOoeK2o2J9WZq5afwLm7p+q9efKlSuxe/duvPjii2jcuDGCg4Nx8OBB3HrrrSgtLcXdd98NQL3+tJJbtf58/PHH9dxdu3bFrl27sH//fgwYMEDPrWJ/Wpm5av1pZuZadpX608rMVepPK7lV608za0XF/rQyc9X60+z9U7X+nDZtGn766Sf971rvh4aGIiEhAfPmzQOgXn9aya1Sf44fPx4RERFu27Tsqampem4V+9PKzFXqT7Mz17Kr1J/jx49Hnz593LaJCCZMmIDGjRujXr16lo9ZaRIgJk6cKFbiApBnnnmm2r7/TTfdJOnp6Za+5ne/+53Uq1dPAJT7tbt375aQkBCZMWOGAJChQ4dWNa6usrl79eolqamphjP3dcxAmPm8efPE6XTKzp079W2q5C5v5kZ69+4tAOTJJ5+sTExD1T3z4uJiiYiIkCFDhrhtByAAZNKkSVXOLFL9M//iiy8EgDz99NNu2//whz8IAJkwYUKVM2vMZt+6dasAkHfeeUdEyn9MvOWWWyQlJUXy8vL0bdrMN23apGzu7OxsuXz5soiIDBw4UBo1amTb/dMzt4hx9pycHNmzZ4/X1993330CQB5++OGqh/6fmpi5EW2trF69utJZXVX3zF159qcq66W83EbHDITcKvVnZdaKKzv70+zMVetPszNXsT/z8vIkKSlJMjIy5MqVKwHTn1Zyq9SfnrlFAqc/rczciF39aXbmrlTpTyszV6k/reRWqT8rs1Zc2dmfZmeuWn+anbmK/elJyw1AZs+e7XabSv3pqbzcKvWnkcGDB3vlVrE/PZU3cyN29acRo5m7UqU/jXz66aeG2atyTDOUvRSSFUbXuTKSnZ2N+++/H0lJSQgLC0N6ejpee+01S9+rpKQEFy5cqHC/Tz75BO+++y5uuOEGn/touSdPnoyMjAyf+9qR+6WXXip3v+zsbDRu3LjCY6o089LSUkyfPh1OpxNdunRBSUmJz7OMKs7cdZ2fPHkSW7duBQCEhLi/8UilmRcXF6OwsBCbNm0yvN317LBKM//0008BAN99953bY8uwYcMAAHv27HHb35/ZASA/P9/nu7TOnz+PjRs34uLFi6hVq5bbbU6nE2+//baSuYGy3+TV3gpZHjtyl5SUGN6WkJCA9PR0rx7KyMgAAOTk5NievbyZl9efubm5+v9Xaeaa0aNH49prry23P+3KXt7MDxw4gIMHD1Z4TJVyq9qfWm4za0W1/tSy+5q5qv2p5fY1cxX7880338Tp06cxe/ZsBAUFobi42HA/1frTbG5Arf70zH3x4kWIiNd+KvanlZmr1J9mZ+6aXZX+tDJzlfrTbG7V+rMya0WV/jQ7c9X60+zMVexPXxwOB+655x7976r1p9ncgFr9aeTgwYMA4JZbxf70xWjmKvWnEaOZa1TqTyNvvvmm4cyrckwzlL0UUnU7ffo0unXrBofDgYceegiJiYn4v//7P4wZMwbnz5/HlClTKjzGwYMHERUVhcuXLyMpKQljx47FtGnT3C4HBABXrlzBww8/jAceeMCrdD0VFBRgx44d2L9/PzIzM5XJ3a5du3KPmZeXh9zcXMTExOjHVCW7r5nv27cPhYWFiIuLw7hx4/DGG2/o1/w7cuSI7bkrmrmrt956y/DFCNVmHhERgYSEBPz8889YtWoVbrjhBr0sIiIiMG7cOFtz+5p5UVERAO8nzZGRkQDKnlhr/JkdAO677z5cuHBBv57fl19+iWuuuUa/fffu3RARhIWFeX1tcnIydu3apWRus+zKHRwcrF+f1YxTp04BuLpm7MxuZuZnzpxBSUkJDh06BKDsSWCPHj1szV3RzDMzM3Hp0iU899xzhv1pZ/aKZl5cXOx2TKDssUnV3Cr2p2tuK/dPFfrTNbuvmavYn665fc1cxf7csmULatWqhezsbNxxxx36D4y///3v8be//U2/3rlq/Wk2t1l25tbWw6VLlyrMbWd/VmbmKvSn1Zmr1J9WZ65Kf5rNrVp/VuX+aXd/mp25av1pduYq9qcn7d+/e/fubi8Mq9afZnObZVfu4uJivVvM5Fbh50+NmZmr0J+eKpq5Sv1plP3tt9/2OfPKHNO0GnsvRDUr7y16o0aNkkaNGrltg8fbUcaMGSMpKSly5swZt/2GDRsmsbGxUlBQUO73v//++2X69Omydu1aWbFihQwaNEgAyF133eW178svvyyxsbHy008/6bmN3nYyYsQICQ4Olj//+c8icvVt5q6XQrIrt4j4vCzP/fffLx06dJDExES3Y6o+83Xr1gkACQoKkubNm8vy5ctl+fLl+rZvv/3W1twivmcu4r7OO3fuLCkpKcrPXEQkIyNDQkND9TWi/Zk4caLtuUWMZ7527VoBINdff73bY8uSJUsEgCQmJvo9+/bt2+XOO++UV199Vf71r39Jt27dBICEh4fL119/re/3zjvvCABJTk52+3oA0qZNG327arlF3Ne4r7ei2pV77ty5EhYWJgC8cntmLyoqkjZt2ni9nVnVmdevX9/r/un69nEVZ15QUCBRUVESGxsrIlf7U5X1Ut7MmzVrJrGxsV7HbNOmjbK5VevPqtw/7e5PK2tFpf40O3MV+7N9+/YSGRkpkZGR8vDDD0v//v31WQ4bNkzfT7X+NJtbRK3+9My9du1aadeunWFuz+x296fVmavSn1Zmrlp/Wpm5Sv1pNrdq/VmV+6fd/WllrajUn2ZnrmJ/eho4cKAAkEWLFrltV60/zeYWUas/PW3YsEFfu0ZU6k9PFc1clf70VN7MVetPX9mNZl7ZY5r1qzixUFpaKnFxcTJu3DjJyclx+6MV+7Zt2yxnGjt2rACQzz77TN925swZqV27trzwwgtuuY1ecO3QoYMEBwdLfn6+iHifWLAzt4j5F7ldjzlmzBjbs/ua+YoVK/Q7/rFjx/Tt2hO74cOHB8TMv//+ewEgjzzySECs87vuukuioqJk4sSJsm7dOlm0aJEAkDp16khOTo6SMy8sLJRGjRpJeHi4JCYmSmZmpqxZs0bq1KkjACQ+Pl5E/DtzT9rMIyIi5Oabb9a3a+s8JSXFbX8A0r59e4mNjVUyt0jFT+zszC1SdjIYgFduz+za8VTJbmbmmzdvlg0bNujXihw0aJDtuUV8z3zatGkSEREhDRs2FBHjJ3aqz9yVlv2zzz5TMrdq/WnEzP1Thf70VN5aUak/jRjNXMX+TEtLE+Dq9am1mY8fP14AyMGDB0VEvf40m1tErf70zO2a3TO3Z3a7+7MyM1ehP63MXLX+rOw619jVn1YfV1Tpz8reP1XoTytrRaX+NDtzFfvTU/PmzQWA1wumqvWn2dwiavWnp7vvvluCgoK8Xqswym53f3oyM3MV+tNTeTNXrT+NsjudTsOZV/aYZv0qTiycPn1a/wf39WfdunWWMx04cEAAyMyZM/VtEyZMkGbNmklRUZFbbs8XXI8cOSLBwcFSp04dfZvniQU7c4tYO7GgHbNnz562Z/c1c+1Menh4uNt2ANK4cWNp0qRJQMx82rRpAkC+/PJL5dd5cXGxxMXFSUxMjNt27cn0448/ruzM9+zZI7GxsXqGsLAwmT9/vgCQpKQkEfHvzD1pMx82bJiEhoZKSUmJiJj7jREVc4tU/MTOztyu2T1zu2Z/7rnn9GOpkt3szDVang0bNig58yNHjkhERIRcd911enajJ3aBOPOZM2cqmVu1/iwve3n3TxX601duz5mr1p/lZfecuWr9mZ6eLgDk448/dsv98ccfCwB54403RES9/jSbW0St/vTM7ZrdM7drdhX6s7Iz19jVn2ZnrmJ/VtfM/d2fVh9XVOnPyt4/VehPszNXrT+tzFy1/nSVn58vISEhAnj/3Kxaf5rNLaJWf3rmjoyM1POUl12F/vTMbnbmGi2PnT9/ljdzFfvTKPutt95abce04lfxGQva9b1GjBiBUaNGGe7Tvn17y8dt0KABAODs2bMAgEOHDmHZsmV46aWXcOLECQBlH2QDlF3vKjMzE7Vq1ULt2rUxbdo0REZGIjw8XL82l3ZNtIsXLyIzMxOhoaG25QauXq/SNXdFxywsLASg5sxTU1MBAEFB3p9ZHhUVhezsbFtzA+Zm/uabb6Jly5bo3Lmz23YVZ/7JJ58gNzfX8DrMCQkJ2L59Ox555BHbcgO+Z56eno477rgDmzdvxpo1a9CmTRtERERg8uTJqFOnDgD/zbyifS9fvqx/WFZKSorbf5er/Px8pKamKpnbDBVyA/CZ+8KFC3jiiScwYcIEPPXUU3j66aeVym5l5tHR0Vi1apV+zXeVZj5t2jTUq1cPycnJyMzMRGZmpt6fQNmHfpWWlgbczLVjqphbpf6sSHnztrs/K9rXNbtK/VkRz5mr1p+pqanYu3ev1yzr1q0LADh37hwAKNefZnOboUJujVFuVfqzOmZuR3+anbmK/Vld69zf/Wk2t2r9WZn7J6BGf5qduWr9aWXmqvWnq3/+858oKSkxvE21/jSb2ww7cxcUFKBly5Y4evSoz+Oo0p+e2Sszc7t//ixv5ir2p1H24cOHV9sxrfhVnFhITExETEwMrly5gj59+lTbcQ8fPqwfH4D+xGDSpEmYNGmS274HDx5EkyZNMHnyZLz00ks4duwY8vPzkZ+fjyZNmrjt++GHH6JJkyY4c+aM7bkBuOWu6JjaB8WoOPN27drB4XD4LLzExEQlcgO+Z15UVISjR49ixowZXl+jQnbPmZ8+fRoAICJexy0tLUVJSYkSuQHfM3c6nbj++usBlN03ASAtLU0/tj+yV7RveHg4oqOjAQBt27aFw+HQPwDM1alTp9C3b18lc5uhQm4AhrmPHTuGn3/+GXfeeScWLlzo9TUqZLcy85KSEuTl5SmRG3Cf+bFjx/DDDz/ghx9+AACvDp0/fz6mT5+uRHar69yfPVTRvq65VerPiviatwr9WdG+rtlV6s+K+Jq5Kv3ZuXNnbN68GdnZ2WjZsqW+XfslA21f1frTbG4zVMjtmsWVSv1ZHTO3oz/NzlzF/qyude7vHjKbW7X+tHr/BNTpT7MzV60/KzNzVfrT1apVq+B0OlFcXOx1m2r9aTa3GXbmjo6O9nqcdqVSf7qq7Mzt/vmzvJmr2J9G2QcNGlRtx7TC+9T5L1BwcDDuvPNOrF27Fnv27PG6PScnp9yvP3/+vNeDpIhg1qxZAICbb74ZQNkD6vr1693+3HLLLQCAhg0bYv369RgzZgwAYNasWejZsycSExP1fWfOnAmg7JPT169fj1q1atmWe/369fpvbrvmruiYzZo1A6DmzGNiYlC/fn0UFRXhwIEDbsfOyspC3759bc3ta+auLl68CAC45557vG5TceYtWrRwy+3qzJkz6NSpk/Iz1xQWFuq/AdC2bVsA/pt5ecd677330K9fP/03oWJjY5GSkoKLFy8iPz/fbd/i4mIMHTpUydxm2J37zJkzAOCV+5NPPsHHH3+M8PBwrFq1yvC/ye7sgPfML1686PO3SS5duoRrrrnG9txGM581axbWr1/v1qFafwLA7373O0RFRdmeHfCe+fnz571eXHD9wffmm29WMrdK/enrWL7unxoV+rO8Y3nOXKX+9HWsimausbs/77rrLgDAq6++6rb/P/7xD4SEhKBHjx4A1OtPs7nNUCE3AK/cqvWn2Zmr1p9mZ65if5qduWr9aTa3av1p5f6pUaU/zc5ctf6szMw1dven6zG3bNmin9zwpFp/ms1thp25MzIyEBJi/LvgqvWnZ3ZfM1etPz1z+5q5iv1plF37Re+qHtOqX8U7FgDg2WefxdatW9G1a1eMHTsWbdq0wdmzZ/H1119jy5Yt5b794+uvv8bdd9+Nu+++G82aNUNhYSHWr1+P7du3Y9y4cfjNb34DoOytdXfccYfb127ZsgVA2ZMK19uuv/56NGzYEIcPH9a3x8XFAQDq1aunb7MrNwBMnDgRANxu045Zu3Zt5Ofn48UXX9SPCVx9G5yKMweA3/zmNzh+/Dh69erl9lvrERERmDp1qpIz14gILl68iG7duqFp06aG31+1mXfu3BkpKSk4efIkBg8ejH79+uHkyZMAyn4TY8qUKbbmBnzP/K677sKePXtw4cIFvPDCC3jttdf0s7phYWF+nTlQVlYRERHo3r076tati23btgEoe5fQs88+63bc3/zmN3j//fdx0003Ydy4cTh+/DiAst906d+/v7K5z507h7y8PMyaNQs//PAD8vLyAJQ9cdqwYQNuu+0223Lv27cPa9eu1WenOXr0KAYNGgSHw4HIyEi88847bt9T+60pFWd+6NAhvPvuuwgNDcWCBQsQFBSEL7/8EkDZDwiTJ0+2NbevmWu/wfXPf/5T71CtPwGgVatWcDqdSs7866+/1me+aNEi/ZhA2f1WO6ZqubV8KvSnUW5fa0WjSn9amblK/Wl15qr1Z6dOnXD//ffjtddeQ0lJif7W9dWrV+PPf/6zfqkSQK3+tJJbpf70zH3TTTdh48aNAIDHHntMz61if5qduWr9aXbmKvan2Zmr1p9WH1dU6U+za0WjUn+anblq/Wll5qr1p2bNmjUoKSlBixYt8P333xseV6X+tJJbpf70zD18+HBs2LDB63YV+9Mzu6+Zq9afnrl9zVzF/jTKXl3HtKzKn9LgJ1X58GbN6dOnZeLEidKgQQNxOp2SnJwsvXv3lmXLlpX7vQ8fPixDhw6Vxo0bS3h4uERGRkrnzp1lyZIlUlpaaiq354faGuX2/PBmO3OLGH+orXbMqKgoAeB2zECZeUpKivTp00eioqIkJiZGAMhDDz1ke26R8j+8uU+fPgJA/v73v+vbAmHmI0aMkLi4OGnTpo1EREToH0g1fvx423OL+J75vHnzpFatWgJA4uPjZdCgQbJr1y7bZj5//nzp0qWL1K5dW0JCQiQyMlIAyKFDh7yOO2rUKElOTpbu3btLeHi4JCYmCgD505/+pHTu6667zueHHI0aNcrW3CkpKdKiRQuvteL6oU1Gf2666SZlZ56TkyMtWrSQkJAQiYqKktDQUGnevLkAkMcee8z23L5mrnHtUKMPz7Izu6+ZHz58WBo1aiTBwcFuxwQg06ZNUza3iFr9aXWtqNSfVmauUn9amblq/SkicvnyZZk+fbo0atRIgoKCBID87W9/89pPpf60klul/vTM7XQ69bXrSsX+9Mzua+aq9adnbl8z16jUn57Zfc1ctf40m1tErf70zF3RWlGpPz2zlzdzlfrTM3d5M1exP0VEunXrJnXr1pUHH3yw3McVlfrTbG7V+tM1d0lJieHroKr2p2t2XzNXsT9dc/uauUa1/vTMXl3HtMohYnDxOSIiIiIiIiIiIiIiIgO/is9YICIiIiIiIiIiIiKi6sETC0REREREREREREREZBpPLBARERERERERERERkWk8sUBERERERERERERERKbxxAIREREREREREREREZnGEwtERERERERERERERGRaiN0BVONwOHzeJiJ+TGJNoOYGAjd7oOYGAjc7c/tfoGYP1NxA4GZnbv8L1OyBmhsI3OzM7X+Bmj1QcwOBm525/S9QswdqbiBwswdqbiBwszO3/wVq9kDNDQR2dk98xwIREREREREREREREZnGEwtERERERERERERERGQaTywQEREREREREREREZFpPLFARERERERERERERESm8cQCERERERERERERERGZxhMLRERERERERERERERkmkNExO4QREREREREREREREQUGPiOBSIiIiIiIiIiIiIiMo0nFoiIiIiIiIiIiIiIyDSeWCAiIiIiIiIiIiIiItN4YoGIiIiIiIiIiIiIiEzjiQUiIiIiIiIiIiIiIjKNJxaIiIiIiIiIiIiIiMg0nlggIiIiIiIiIiIiIiLTeGKBiIiIiIiIiIiIiIhM44kFIiIiIiIiIiIiIiIyjScWiIiIiIiIiIiIiIjINJ5YICIiIiIiIiIiIiIi03higYiIiIiIiIiIiIiITOOJBSIiIiIiIiIiIiIiMu0XcWJh9OjRaNy4sds2h8OB6dOn25LHrEDNDQRu9kDNDQRudub2v0DNHqi5gcDNHqi5gcDNztz+F6jZAzU3ELjZmdv/AjV7oOYGAjc7c/tfoGYP1NxA4GZnbv8L1OyBmhsI7Ow1SdkTCw6Hw9Sfjz76yC95evToYfj9+/fvX+Xcc+bMQatWrRAeHg4AWLVqFY4fP+7X3KNHjzad3eFw4I033sDRo0fdtgHAe++9Vy25rWS3MnMRQX5+Pjp27Ijo6GgkJSUBALKysvye28rMt2zZgm+++QbZ2dkICwtDWloaZs2aVW2ZrWa3us6Liopw/fXXIzIyEsnJyQCAy5cvK537xIkT+Pnnn9G2bVsEBwd7FYg/c1vJPnnyZPz73/9GVlYWYmJi0KlTJyxevNi27FZm/t133+HkyZNITExEeHg4mjdvDgC4ePGi33Nbza7Jzc1F3bp19cfE6lQTM9+4caPhY/n/+3//z++5rWYvLS1FXl6e3p/a4/n58+f9nt1s7rfeestnf/7lL3/B2LFjlcytWn9ayc7+rJ7cVrI///zz2L59O06cOFFj/Wklu9ncGzduxIEDB3D69GmkpKToHQoApaWlyuZmf1Zfdiu52Z/Vk91sbvZn9eS2kt1f/QmU9ZrrayJJSUkYOHCg22siVh9Xaro/zea2kt1f/Wk2u9nc/urP6s7tr/40m9tqdk1N9qfZ7Kr1p9ncVrP7oz+tZC8qKsITTzyB1NRUREREoGvXrti8ebPbPpmZmeX+d1VHf4ZU+Qg1ZOXKlW5/X7FiBTZv3uy1vXXr1njllVeq/QHLSP369TF37ly3bampqW5/nzZtGn766Sf979u2bcOePXsQGhqKhIQEzJs3T8+9aNEi3HbbbZg9ezbGjh2L9u3bY8yYMQgNDUVeXh7q16/vt9zjx49HRESE2zYte2pqqp67qKgIly5dQlRUFEQETqcTALBx40asWrUKTZs2rZbMVrJbmXl8fDzOnj2LAQMG4MEHH0Rubi6eeOIJLF++HOPHj0eXLl38ltvszAFgwYIF+PbbbzF69Gh07doVn3/+OZ5++ulqyVqZ7C+99BKmTp2KiIgI9O7dG7t378b+/fsBAJ06dcKjjz4KoGzmEydOxFtvvYWCggL89a9/xfHjxzF79my8/fbbmDNnjrK5k5OTUVxcjNjYWK/jVCczubOyshAZGannjoqKwqZNm3DixAm33FlZWZg6dSp69eqFhx9+GLVr18amTZvw4IMP2pbdyswbNWqEzp07Iz09HTExMdi/fz9efPFFvPrqq5g+fTqioqL8ltvszLXsWg899thjKCgoqJaclc1uZeYtWrRASEgInn32Wf3rR44cieuuu87vua3MvFmzZsjOzkZRURH69++P9u3b49y5c/jjH/+IS5cu+T272Zl36dIFy5cvd+tPoGzmANCvXz8lc6vWn1bWimr9OXPmTMyYMQO1a9dGr1698OWXX+LQoUMIDw/HjBkzkJKSAkC9/vz666/hdDr13CKCf/7zn7h06RKee+45PTcAbNiwAVlZWejcuXO1/aJMVbKbnXl4eDh27tyJXr16oX///qhVqxY2bdqEb775Bv/6178wY8YMJXOr1p9W1opq/Wll5ir1p5WZq9afZmeuWn9aWSsq9aeVteKv/iwuLsbAgQOxY8cO/TWRc+fOYefOnW6viaxcuRILFy7EF198gf79++PIkSPYv38/goKCMHXqVLRs2RKA//rTbG4A6Natm547KSkJ69atQ15eHp566ik9N+C//qzumfurP2tirfijP2tirfirP2ti5v7oz5qYub/600r20aNH491338WUKVPQvHlzvP766xgwYAC2bt2K66+/HgCQmJjo9To6cPU13GrpTwkQEydOFCtxAcgzzzxTbd//pptukvT0dMtfp+UGILNnz3a7bd68eeJ0OmXnzp36NlVyi4gMHjzYMLeR3r17CwB58sknK/W9jFT3zIuLiyUiIkKGDBnitr+276RJk6qcWaT6Z/7FF18IAHn66afd9v3DH/4gAGTChAlVyuvKbPbZs2cLANmzZ4+IXJ35vffeKwDk7Nmz+r633HKLpKSkSF5enr5Nm/mmTZuUzZ2dnS2XL18WEZGBAwdKo0aNbLt/euZ2ze6aOycnx20fzX333ScA5OGHH7Y9e3kzN6L9N65evdrW3CLGM3e1e/duCQkJkRkzZuj7qbBeypu50TFVye2a3TO3UX+qlL0y6zw0NFQKCwuVzK1af5pdKyr254ABAyQ+Pl7OnDnjljs6OloGDx7stq9K/emZW0Rk9OjRAsArt1F/atntuH+anbmvDtVmfujQISVz+2JXf1pZKxpV+tPKzFXqTyszV60/q2Od29GfZnOr1p9m14o/+9PXmvS0c+dOASDPP/+8iFydedOmTeW3v/2t277+6M/K5hYRGT9+vADwyu2v/qzumfurP2tirRip7v6sibWiqen+rImZ+6M/a2Lm/urPqmQvLCw0vc579+4ttWrVqpb+VPZSSFYYXefKSHZ2Nu6//34kJSUhLCwM6enpeO211yx9r5KSEly4cMFyRofDgXvuuUf/e2lpKaZPnw6n04kuXbqgpKTE51lGu3IfPHgQANxya1xnfvLkSWzduhUAEBLi/iYYlWZeXFyMwsJCbNq0yXB/13cPqDTzTz/9FADw3Xffua3zYcOGAQD27Nnjdgx/ZNfe6qW99UuTkpKCoKAghIaG6vtt3LgRFy9eRK1atdz2dTqdePvtt5XMDQBTp07V3wpZHjtzA3DLnZCQgPT0dK/HxIyMDABATk6OMtmNZl7eY3lubq4SuQF45dayX3vttcjIyMANN9zg87iqzfzAgQM4ePBghcdUaealpaWYP38+6tWrh7vuuqvc/rQ7u5l1fvLkSQBlv8GjXRJRtdyq9afZtaJif3766afo06cP6tSp47b9pptuwvvvv69/rWr9aZRb+y0+19xA2W/Ijh07Vpnn5mZnnpCQgOeff95nbu3dPKrlBtTqTytrRcuuSn9amblK/Wl25ir2Z1XWuZ39aTa3av1pdq34qz+1NZmRkVHhayLvvvsugoODMW7cOLftY8aMwWeffaZfWsof/VnV3NprJq65Af/0Z03M3B/9WRO5gZrvz5paK1r2muzPmpp5TfdnTczcX/1Z1ezh4eGGM/ekvYY7ePBgt/6srF/EiQUzTp8+jW7dumHLli146KGHMH/+fDRr1gxjxozBSy+9ZOoYBw8eRFRUFGJiYpCcnIynn34axcXF5X6Ndomm7t27uz1g7du3D4WFhQgNDcW4ceMQFRWll/qRI0dsz11cXIxDhw4BQIXF9tZbbxleikq1mUdERCAhIQEXLlzAqlWrcOzYMXz33Xf6bdodUrWZFxUVAfA+aRMZGQng6pNqf2bv0aMHgLKi+Oabb/RCWLx4MSZNmqSv5d27d0NEEBYW5vV9kpOTsWvXLiVzm2VX7qysLH2tmMl96tQpAFfXjJ3Zzcz8zJkzOHXqlP5DjcPh0I+j6swzMzP1t5H7ourMi4uL3Y4JAFeuXLE9t6+Z79u3DydOnEB8fDx+/vlnvT/bt2/v9X1Vnbmrt956CwDc8quWW7X+NLtWVOzPoqIir8sgapkuX76sv1ijWn/6yg3ALbcVdmf3nHlFEhISlM+tQn9aXSsq9afVmavSn2ZnrmJ/VuX+aWd/ms2tWn+aXSv+6k9tTbZv397tNZH27dvrv7io2bVrF1q0aOF1skC7lNQ333wDwD/9WR25NVpuK+zO7jnzilRHf9Z07prqz5pcKzXdnzU585rsz5qYub/601/3T+013OHDh5ebx7Qqv+fBT8q7FNKoUaP0t4lp4PF2lDFjxkhKSorb2/5ERIYNGyaxsbFSUFBQ7ve///77Zfr06bJ27VpZsWKFDBo0SADIXXfdVe7XDRw4UADIokWL3LavW7dOAEhQUJA0b95cli9fLsuXL9e3ffvtt7bm3rBhg/5WKiOuM+/cubOkpKQoP3MRkYyMDAkNDdX/27Q/EydOtD23r5mvXbtWAMj111/vts6XLFkiACQxMdGW7DNnzpSIiAi3OXpeCuudd94RAJKcnOy2HYC0adNG365abhH3Ne7rUkh25zZz/ywqKpI2bdp4vZ3Z7uy+Zl6/fn2v/0bXt4/bndto5gUFBRIVFSWxsbEiIrJ161bDt6Land1o5s2aNZPY2FivY7Zp00aZ3J4z1/ozLCxMQkJC9P5s3ry519vz7c5e0WOLSFmHApBp06YpnVu1/jSzVlTsz3bt2kmLFi2kpKRERK4+v23YsKEAkHfffVdE1OtPz9wiIhMmTNDnruXWaOu8vEs5qDZz19yaoqIiASBxcXFSXFysdG5V+tPKWlGtP63MXKX+NDtzFfuzKvdPO/vTSm6V+tPsWvFXf2prsk6dOm6viTRv3lxCQ0P110RERNLT06VXr17637WZ7927VwDIkiVLRMQ//VmV3K7ZXXNraro/a2Lmrrk11d2fNZm7JvuzptaKP/qzpmZe0/1ZEzP3V39WNbuIGM7ck/Ya7pUrV3zuY8Wv4sRCaWmpxMXFybhx4yQnJ8ftj/Zi/rZt2yxnGjt2rACQzz77zOc+2kLzXFQrVqzQF+uxY8fccgcFBcnw4cNtzX333XdLUFBQhTP//vvvBYA88sgjys9cROSuu+6SqKgomThxoqxbt04WLVqk33FzcnKUnHlhYaE0atRIwsPDJTExUTIzM2XNmjVSp04dASDx8fEi4v+Zr1y5Um6++WZZtmyZ9O/fXwCIw+GQBQsW6Pto6zwlJcXtawFI+/btJTY2VsncIhWfWLAz99q1a6V169YCwCu3Z3bteKpkNzPzzZs3y4YNG/RrRQ4aNMj23OXNfNq0aRIRESENGzYUEeMndqrP3JWW/bPPPlNy5trjSlBQkNSvX1/ffvToUQEg7dq1E5HAmLnWoYGwVlTrTzNrRcX+XLx4sQCQUaNGyd69e2XYsGECQJxOpwCQlStXioh6/emZe/fu3dKsWTN9/Wq5NRW9MKLizF1zex7vnnvuCYjcKvSnlbWiWn9WZa2I2NefZmeuYn9WduZ296eV3Cr1p9m14q/+1NZkaGio22siR48eFafTKcOHD9e3paWlyS233KL/XXt96McffxQA8re//c3tmDXZn1XJ7ZrdNbempvuzJmbumltT3f1Z07lrqj9raq34oz/9tVZEqrc/a2Lm/urPqmYXEcOZu3J9Dbe6/CpOLJw+fVpfGL7+rFu3znKmAwcOCACZOXOm4e35+fkSEhJimFs7kx4eHu6Vu3HjxtKkSRNbc0dGRuovpBrRZj5t2jQBIF9++aXyMy8uLpa4uDiJiYlx2649QDz++OPKznzPnj0SGxurZwgLC5P58+cLAElKShIR/8589erVEhERIVlZWSJy9f45evRoiYyM1E/qmPmNERVzi1R8YsHO3K7ZPXO7Zn/uuef0Y6mS3ezMNVqeDRs2KDnzI0eOSEREhFx33XV6dqMndoE485kzZyo5c9fHFaPscXFxIhIYM9c6VPW1olp/WnlMVK0/RUSmTp2qv/ik/XnyyScFgKxfv15E1OtPo9yJiYn6/9dyayp6YcTu7EYzd80tInqHBlpujba/v/vTKLfRWlGxP42yV2bm/u5Po9xGM1exP42ym5m53f1pNrdq/WmU29djuT/6U1uTPXv29LqtZ8+e0qRJE/3v1fmOBTtzu2Z3za2p6f6siZm75hapmf70R26Nlqc6+rMm1oq/+tOOmVdHf9bEzP3Vn1XNLlLxOxZcX8OtLu4XzfuF0q65P2LECIwaNcpwH6NrY1WkQYMGAICzZ88a3v7Pf/4TJSUlhrelpqYCKPuQQU9RUVHIzs62NXdBQQFatmyJo0ePlnusN998Ey1btkTnzp3dtqs4808++QS5ubmGH/aYkJCA7du345FHHrEtd3kzT09Pxx133IHNmzdjzZo1aNOmDSIiIjB58mT9w7f8OfNFixahU6dOqF+/vtu+gwYNwuuvv45du3ahT58+SElJAeB+vTxNfn4+UlNTlcxthgq5AaCgoMAw94ULF/DEE09gwoQJeOqpp/D0008rld3KzKOjo7Fq1Spcc801tucG3Gc+bdo01KtXD8nJycjMzERmZqb+mRZA2Yd+lZaWBtzMtWOqkBtwn7nWn+Hh4RARr30LCwsBBMY61zr0+++/17epmFu1/rTymKhafwLA7Nmz8cc//hF79+7FwoUL3T6rqkWLFgCgXH965o6NjcXSpUuxcOFCt9xmqThzV6+//rreoUuWLAmY3J7s6E/P3L7Wior96Zm9MjPXjqni/VPF/vTMbnbmdven2dyq9adn7vIey/3Rn9qaNJpP3bp19c9DAMp6MTs722s/7fMetGP5oz+rI7fnscxSIbvnzF3VVH/WdG5P1dWfNbFW/NWf/p45UD39WRMz91d/+mPmvl7DrYpfxYmFxMRExMTE4MqVK6ZfNDTj8OHD+vGNrFq1Ck6n0/BDe9u1aweHw+Gz8BITE23NHR0djSZNmpR7nKKiIhw9ehQzZszwuk3FmZ8+fRoADB8ISktLUVJSovzMnU4nrr/+egDAhx9+CABIS0vTj+2v7KdPn0Z8fLzXvtrctZM7bdu2hcPh0D8AzNWpU6fQt29fJXOboUJujWfuY8eO4eeff8add96p/6DgSoXsVmZeUlKCvLw8JXK7ZgLKZv3DDz/ghx9+AACv+/D8+fMxffp0JbJbXef+7iGzM2/Xrh2cTicKCgoMP4BQ++BeFbKXN/OdO3fihx9+wIwZMzBt2jR9u4q5VetPq4+JgDr9qYmPj8f111+vf/joli1bUL9+fbRq1QqAev3pmduVa26zVJy5pqCgAA888AAGDx6MhQsXur0wonJuI3b0p2duV665VexPz+yVmbl2TBVnrmJ/emY3M3MV+tNsbtX60zO3K1/zrsn+1Nak0YtjJ06ccMvesWNHbN26FefPn3f7sNKdO3fqtwP+6c/qyO16uxUqZPecuaYm+7Mmcxuprv6sibXir/7098yB6unPmpi5v/qzpmfu2p/VyfvX5X+BgoODceedd2Lt2rXYs2eP1+05OTnlfv358+e9iklEMGvWLADAzTffbHjMLVu26KXrKSYmBvXr10dRUREOHDjgdltWVhb69u1ra+6MjAyEhJR/3unixYsAgHvuucfrNhVnrv0Ghpbb1ZkzZ9CpUyflZ64pLCzUfwO9bdu2APw78xYtWmDXrl04ePCg2/6rV69GUFCQfhY2NjYWKSkpuHjxIvLz8932LS4uxtChQ5XMbYYKuQF45f7kk0/w8ccfIzw8HKtWrTJ8V5QK2T1nfvHiRZ8veF+6dAnXXHONErkB95nPmjUL69evR8+ePZGYmIj169dj5syZ+r6/+93vEBUVpUR2z5mfP3/e6+S26w++N998sxK5AfeZx8TEYMCAAcjJyXE7ibx//34AV3/YVSF7eY8tb775JgDvDlUxt2r9aeUx0ZPd/enLf//7X0yZMkV/zFatP40cOnQIANxym2V3dsB75kDZi4A5OTm48cYbDTtUxdyq9acRo7WiYn/64jlz1frTiNHMVexPX4zunxoV+tNsbtX604jZx/Ka6E9tTe7YscPtNZH9+/djx44d6Nu3r75tyJAhuHLlCpYtW+Z2jOXLl6Nr1676OzT80Z9Vza09frjmNsvu7ID3zIGa78+ayO2P/qyJteKv/qyJmfujP2ti5v7qz6pmLyoqMrx/anz1Z5VV20WValhVPmNBROTUqVPSqFEjiYyMlMmTJ8vSpUtl7ty5MnToUP3Dh3zZunWrJCcnyyOPPCILFy6UF154Qa677joBIOPGjTP8mgULFggAue2223zmvv3228XhcEhKSorMnTtX5s6dK0DZ9YGPHz9ua+6NGzeWO/N7771XgoKCpFu3bvq2QJh5SkqKAJCMjAxZvHixfn0xp9MpBw4csDV3eTMfOnSotG7dWurUqSPPP/+8tG7dWsLCwmyb+ccffyzBwcFSt25dmTFjhtx44436NeMeeOABt31vvfVWASCdOnWSxYsX69ceTUtLUzr3oEGDJC4uTmbOnCktW7aUuLg4/Xp37733nq25Fy5cKA0bNvTKnZmZKbGxsRIcHCy1a9eWlStX6n8AyIQJE5Sd+a5duyQsLExiYmLk73//u7z88ssyevRoASCxsbH6NdNVm7nGtYeMrnGp4sy3bt0q4eHhUqtWLa9j/uY3v7E9d3kz37t3r4SEhEhwcLDen9rju+sHUak2c5GrayUpKUnvUNXXioha/WllrajYn71795Z58+bJP/7xD2nTpo0AkP79+0txcbHbvqr1p2vuBx54QBwOhwDwyv3tt99Kp06dJC4uTu9P7bN+hg0bZnt2XzPPzMwUp9MpDodDFi5c6NafGRkZ8u233yqZW8X+NLtWRNTrTzMzV7E/zc5cxf40+5ioWn+aza1af5pdK/7oT5GyNRkdHe32mkhKSookJibqr4m4ZgoJCZHHHntMevToIQAkJCREPv74Y7f9aro/q5J76dKlkpycLAC8cvujP2ti5v7oz5rI7Y/+rEru8taKSM33Z03M3B/9WVMz90d/VjV79+7dDR8TRURKSkrc+rM6/WpOLIiUfZDGxIkTpUGDBuJ0OiU5OVl69+4ty5YtK/d7Hz58WIYOHSqNGzeW8PBwiYyMlM6dO8uSJUuktLTU8Gu6desmdevWlQcffLDc3CkpKdKnTx+JioqSmJgYASAPPfSQ7blLSkrKnXmfPn0EgPz973/XtwXCzEeMGCFxcXHSpk0biYiI0D+Qavz48bbnLm/m8+bNk1q1agkAiY+Pl0GDBsmuXbtsnfnOnTvllltukeTkZAkKChIAMnv2bMMfApKTk6V79+4SHh6uf0DYn/70J6VzawVn9GfUqFG25nY6nfra9fxB11dmAHLTTTcpO/OcnBxp0aKFhISESFRUlISGhkrz5s0FgDz22GO25/Y1c42ZJ3Z2Zfc188OHD0ujRo0kODjY7ZgAZNq0abbnrmjmt956q4SHh+v9efvttys/c5GytVK3bl23Dg2E3Kr1p9m1olp//vDDD9KvXz9JSEiQsLAw/aR1UVGR13FV6k/P3K1atZJu3boZPmdZvny5zx7q0KGD7dl9zbyiDnVdLyrlVq0/rawVEbX60+zMVetPqzNXqT+tPiaq0p9WcqvUn1bWij/6U/PVV1+5vSZy++23y8GDB732KywslD/+8Y9uz1k2btzotV9N92dVcoeFhenr2JM/+rMq2X3N3B/9WRO5/dGfVcld3loRqfn+rEp2XzP3R39WJXdFM6/p/qxq9muvvdbwMVFEZOPGjV6v4VYXh4jBBf+IiIiIiIiIiIiIiIgM/Co+Y4GIiIiIiIiIiIiIiKoHTywQEREREREREREREZFpPLFARERERERERERERESm8cQCERERERERERERERGZxhMLRERERERERERERERkGk8sEBERERERERERERGRaTyx4MHhcPj8o7JAzQ0EbvZAzQ0Ebnbm9r9Aze5wONDA4cCPDgfg8udHxXMDgT1z5vavQM0eqLmBwM3O3P5X36WDfvxfJ2ndpLJAnnmgZmdu/wvU7FpGo+e4aNrU7njl8vW8nI+JNSdQszO3/wVq9kDNDQR2dk88sUBERL9IxwGM9Njm+XciIqKakA2gB4AfATQF8GlwMB6//np8bGsqIvolMHqOi5UrbUhinq/n5cdtyEJERNXHISJidwiVlHd2SOVRBWpuIHCzB2puIHCzM7f/BWp2h8OB+gA+QtkLOpofATRVODcQ2DP3hblrRqBmD9TcQOBmZ27/07IbdREUzv5LmLkRlbMzt/8FavZyH1fS0oAff/R/KJMaOByGz8t7AMgKgJkbUXmtAIGbnbn9L1CzB2puILCze+I7FoiI6BfH9QeuHwF0x9XfGiUiIvIXw98sJiKqJF/PcXH4sH2hTPgIxs/LP7IvEhERVQOeWCAiol+cj3D1h5ceAD7D1UtSEBER+Ut9AGpfoISIAkU9+H6Oi7Q0m1KZ4+t5OX/ph4gosPHEAhER/eL8hKs/vGjXbj3+v78TERH5g8/fLCYiqoR8+H6Oi48+siWTWb6el/MxkYgosPEzFoiI6JcnLw/Izwfq17c7CRER/RodPw7cdFPZ5UnS0spe9GvQAMjKKvtfIqLKCNTnuMePG2f2tZ2IiAICTywQEREREREREREREZFpvBQSERERERERERERERGZxhMLRERERERERERERERkGk8sEBERERERERERERGRaTyxQEREREREREREREREpvHEAhERERERERERERERmcYTC0REREREREREREREZBpPLBARERERERERERERkWk8sUBERERERERERERERKbxxAIREREREREREREREZnGEwtERERERERERERERGQaTywQEREREREREREREZFpPLFARERERERERERERESm/SJOLIwePRqNGzd22+ZwODB9+nRb8pgVqLmBwM0eqLmBwM3O3P4XqNkDNTcQuNmZ2/8CNXug5gYCN3ug5gYCNztz+1+gZg/U3EDgZmdu/wvU7IGaGwjc7Mztf4GaPVBzA4GdvSYpe2LB4XCY+vPRRx/5LdPly5cxZ84ctGrVCuHh4UhKSsLAgQNx/PjxSuUWEeTn56Njx46Ijo5GUlISACArK8vvua1k37JlC7755htkZ2cjLCwMaWlpmDVrVrVmtpLd6lopLi5G//79ER0djdq1awMALl686PfcFy5cMJ198eLF+Pzzz3Hy5Ek4nU44HI5qzWs1u9nc//nPf/DDDz/gp59+QoMGDRAVFYW2bdsCAEpKSpTN/dFHH+HgwYM4deoUkpKSEBYWhiZNmgAAcnNz/Z7bylpxfUwsLi5GmzZtamy9VPfMt23bhqNHj7ptB4CXX37Z77mtztz18TwiIgJ16tQBAJw6dcrv2a3kfuONNwxn/pe//AV9+/ZVNjcAFBQUoFu3boiLi9PnffDgwWrLbDa31bWyf/9+vT/r1auHRx99tFozW8keqP353//+l/3p59xWZv7HP/4RGzduRFZWlt6f9913X7VmtpK9Mv0JXO1QANixY4fSuVXqTytrhf1ZPbmtzjwzMxMnT57U+/Omm26qtrxWs1u9f+bn56N169Z6h2rfR/XcqvTn3r172Z9+zm1l5uxP/+dWqT+trBX2Z/Xktjpzlfpz7969GDp0KNLS0hAZGYmEhATceOON2LBhg+ExX375Zbf+fPTRR6uth0Kq5Sg1YOXKlW5/X7FiBTZv3uy1vXXr1njllVdQWlpao3mKi4sxcOBA7NixA2PHjkX79u1x7tw57Ny5E3l5eahfv76ee+HChfjiiy/Qv39/HDlyBPv370dQUBCmTp2Kli1b6rnj4+Nx9uxZDBgwAA8++CByc3PxxBNPYPny5Rg/fjy6dOnit9wA0K1bNz13UlIS1q1bh7y8PDz11FN6bgBYsGABvv32W4wePRpdu3bF559/jqeffrrKWSub/a9//SseffRR1KlTB4mJiThw4AAA7zXUunVrPPPMM3j//ffxww8/YM6cObhw4QKefPJJrFy5ErNnz0ZoaKjfcp85cwYA3HKnp6dj7969Xtm/+eYb/Pjjj2jXrh0uXrxY7S+eWc1uduaNGzfG9u3b0aVLFwwaNAh169bFZ599hr179+L//b//h5kzZ1bLk9SaWCvt2rVD06ZN0bFjR8THx+PIkSOYNWsWli1bhscffxypqal+y21lrbg+Ji5YsADHjh2rcs6qZLcy8+7duyMrKwuvvvqqvn3kyJHV+gSjpmYuIsjLy8Mdd9yBhx56CBcvXsSUKVOq9YfGmpj58uXLISJwOp369pEjRwIA+vXrp2zujh074o033kCXLl3w7LPP4tKlS3jkkUewevVqDBkyBIMHD/Zbbitr5d1338UXX3yBjIwM9OvXD/v27cOCBQuqnLWy2a+99locPHgQXbp0QcOGDfHRRx/hxx9/RFhYGJ555hk0aNAAgHr9OW/ePMTGxuq5c3NzsWHDBv1JuJYbUK8/zc5ctf60MvMtW7agX79+SE9PR2JiIo4cOYJXXnkFQNmLgtWlJta5688UNdWhNZFbpf60slZU608rM1epP63MfPv27fj444/Rv39/3H777bh06RJef/11AMD+/furJbeV7FZmnpCQgLNnz6JXr16YPHmy3qFr1qzBnDlz/Jr7D3/4A/7973+jWbNmiI+Px/bt2/H9998DAO677z706tVLz61Sfx49ehTt2rXTc1++fBnvv/8+cnNz3XID6vWn2Zmr1p9WZq5af1pZ5yr1p5XcKvWnlbWiWn9amblK/Wll5qr159GjR5Gfn49Ro0YhNTUVBQUFWLt2LQYNGoSlS5di3Lhx+jGfeOIJPPfccxgyZIhbf+7duxebNm2qemgJEBMnThQrcQHIM888U23ff968eeJ0OmXnzp3l7rdz504BIM8//7yIXM3dtGlT+e1vf6vvV1xcLBERETJkyBCv3ABk0qRJtuYWERk/frwAcMv9xRdfCAB5+umn3b7+D3/4gwCQCRMmVEtuK9kvXbokJ0+eFBGR//73v/oMjfz+97+XiIgIOXr0qL5N23/p0qW25+7Vq5dh9lOnTklBQYGIuN8X7FrnZmdeVFQk27dv99qu7b9582Ylc/ui7T937twq5dXUxFrRnD59WmJjY2XGjBl6bpXXiojIqFGjJCoqym2bSrl9zXzNmjUCQNatW6ds9sqs86ysrCrl1dRE7ubNm8u1114rpaWlbrmdTqcMGjTI9txGa+XEiRMSEhIiI0eOdNu+YMECASDDhg2rltxWsm/fvl2Kior0v2v9EhYWJsOHD3fbV6X+9MwtIjJ8+HAB4JVbtf40O3PV+tPKzI18+eWXAkB69+5dpbyuamKdazw7tG/fvkrnVqk/rawV1fqzMmvFlV39aWXmRv2Zl5cnAKRFixbVkrsq2X3N3FeHajN/7733/Jrbk5a7Q4cO0rJlS7fbVOpPIw8++KAA8MqtWn968jVz1frTiK+ZG7GzPz2Vt841KvSnp/Jyq9SfRnytFdX605OZteLKrv404mvmqvWnkZKSEq+ZV/QzaHX0p7KXQrLC6DpXRrKzs3H//ffrlzZJT0/Ha6+9VuHXlZaWYv78+cjIyECXLl1QUlKCgoICw33fffddBAcHu50dAoAxY8bgs88+0y9zVFxcjMLCQp9nhyIiImzPHRJS9oYW19yffvopAOC7775zm/mwYcMAAHv27HE7rj+yh4WFITk5ucJjAsDy5cvhcDjQsGFDt+21a9fG22+/rWzupKQk/P73v1dmnZvNHhoaimXLlvnM7XpmV6XcQPmPK66XQ1Itt5a9adOmaNmyJUaMGOFzP9Wyb9u2DQUFBbhy5QrOnz8fMLn/+te/IiEhAY888ghKS0vL/S0R1bJ7rvOioiIAQKNGjdze0aZa7qysLOzZs8frN85CQ0P93p9mc3/22WcoKSnBiRMnlOnP7t27G/6mZHp6utdv3qjUn0a54+LiAHj/xpBq/Wl25qr1p5WZA96PLdr/v3Tpktt+Ks3cNfef/vSncjtUtdwq9aeVtaJaf1ZmrWjs7E8rMz9//jxOnjypX+ITAGrVqgUAbr89amd2wHvmWof6+tn5rbfe8mtuXxo0aOB12VSV+tOI9lzKM7dq/emL58xV608jvmYOqNWfvhitc5X600pulfrTiK+1olp/+lLeWtHY2Z9GfM1ctf40Ehwc7DVzrT+1nzk12t9d+7OyfhEnFsw4ffo0unXrhi1btuChhx7C/Pnz0axZM4wZMwYvvfRSuV+7b98+nDhxAu3bt8e4ceMQFRWFqKgotG/fHlu3bnXbd9euXWjRooW+wDTaZY2++eYbAGUnDhISEnDhwgWsWrUKx44dw3fffaffpr3Ab3dujZZbu9NrJx00kZGRAICTJ0/q2/yV3azs7GxcunQJYWFhXrfVq1cPu3btUjK3FYGWPSEhQfncP//8M3766Sd8+eWX+rbevXsrnfvMmTO4cOECXnrpJZ9v9VU1u4igVq1aiI2N1a9B63rtXNVynz9/Hl988QUSEhKQm5uL2NhYREdHIy0tzWtf1bIb+fDDDwEA7du3Vzp3cnIyCgsLsWDBAmRmZuqXTSoqKsLkyZOVzB1I/Xn69Gn98RkIjP4UEQBwy22FajOviAr9WdHMS0tL9f7UrhHt+sOYqjO/fPky3njjDZ8dqmpulfvTaK0EUn+auX+q1p++7p89evRAdnY28vPz9f6cOHEiAKBr165KZNe+v2t2rUN9Pa/96quvbMl98eJFnDlzBnl5eQCA//u//9N/TgDU7U8t948//qj/nO+a2wrVZl4Ru/rTysxV60+zM1etP83mVq0/K1orKvdnZe6fKvSnmfunqv3pmv1vf/ub18y1/nT95Tvg6s+gWn9WSZXf8+An5V0KadSoUdKoUSO3bfB4C9CYMWMkJSVFzpw547bfsGHDJDY2Vn+bn5F169YJAKlTp440b95cli9fLsuXL5fmzZtLaGiofPvtt/q+6enp0qtXL6/ce/fuFQCyZMkS/baMjAwJDQ3V3/aj/Zk4caLtuV2zu+Zeu3atAJDrr7/ebeZLliwRAJKYmOj37K7Ku3yGdltCQoLbdgDSvXt3ASCXLl2yNXd5l7fR1nl5b0VVbeauuV0BkNDQUDl37pzyucPCwtzun/3799f3UXGtlJaWSkJCgv6WziNHjujZVV8rbdu2lVq1asmaNWtk9erVMmrUKAEgDRo0kOLiYttzG83866+/1t+yHxQUJIsWLZJVq1ZJly5dvC5BoOLMPe+fd955pwCQJ554Quncv/vd7yQ8PNyrP++//34lchutla+++koASKdOndxmvnHjRsH/LuNkZ3YR995/9dVXvf67VOxPTZ8+fbxya1TtTxHfM3fN7UqF/tRUNHPX+2adOnUCZuahoaFy9913i8jVDnW9lIOKuVXtT43RWlG9P0Ws3T9V6U+Nr/vn6dOnJSUlxe3+mZCQoPz9U+vQuLg4t/21faOjo23JrV06WPszZMgQOXv2rH67qv3pmRuAW26Niv1Z0cxdc7uyuz+tzFy1/jQ7c9X600xuFfuzorWicn9W5v6pQn+auX+q2p+u2YOCgrxmrvXnzJkz3b5O+xlU68+q+FWcWCgtLZW4uDgZN26c5OTkuP1Zvny5AJBt27b5/N4rVqzQi+jYsWP69qNHj4rT6XS746alpcktt9zilfvHH38UAPK3v/1Nv+2uu+6SqKgomThxoqxbt04WLVqkL6KcnBxbc7tmd81dWFgojRo1kvDwcElMTJTMzExZs2aNXnjx8fF+n7mr8l6M+uSTTwRwP/khUrZWbrzxRv3Bw87cVTmxoOLMXXNrZs+eLQBkwIABAZH7P//5j3z44Yfy4osvCnD1+pZ25/a1Vl577TUJDg6W+vXri4jxiQW7s1t9LAcgq1evtj230cy1xxUAkpycrG/Pz8/Xn5SKBMbM8/Ly9BfrVV8r99xzj8TExMioUaPknXfekddee00ASFRUlBw6dMj23L7un127dpWQkBCpU6eOHDlyRD788ENp1KiRABCHwyEi9s1cmytQ9tlKJSUl+naV+1NEZP/+/eJ0OgWAW26Nqv0p4nvmrrk1qvSniLmZJyUl6f3ZqVOngJj5ddddJw6HQz+m5wsjquZWtT9FfK8V1ftTxPzMVepPkfLvn/n5+dKyZUuJiorS+7Ndu3YCQB5++GHbs5c384SEBHE4HPLaa6/pHaq9kBIcHGxL7v3798vmzZuld+/eAkAyMjLk1KlT+u2q9qeW+4033tCfh7jm1qjYnxXN3DW3RoX+tDJz1frTzMxV7M/KrBUR+/uzorWicn9anbkq/Wnm/qlqf7pmHzhwoOHMu3btKtHR0W792ahRI3E6nRIcHOwzj1m/ihMLp0+f1u94vv54fuiJq3feeUcASM+ePb1u69mzpzRp0kT/u9l3LBQXF0tcXJzExMR45Q4KCpLHH3/c1tyu2V1zi4js2bNHYmNj9dvCwsJk/vz5AkCSkpJExL8zd1XVdywcO3bM1txVObGg4sxdc4uIvPXWW+JwOAIutwaABAcHy4IFC2zPbbRW8vLyJCkpSTp06KBnNzqxYHd2qzMHIGPGjLE9t9HMtduio6MNswcFBUlxcbHt2c3MXHtxPhDWSmpqqkRERLhtAyDh4eFy11132Z7b12P58ePHpW7dunqG4OBgeeyxxwQo61IR+2Z+8uRJqVWrlgCQ7Oxsw/8uFfvz5MmTkpaWJtHR0QHXn+XN3DW3iFr9aWXmmh9++EEA6L/EouLMtR9uY2Nj9W2eL4yomFtE3f4sb62o3p9WZq5Sf1Z0/+zfv7/Ur1/fbeY///yzAJA2bdrYnr28mQ8dOtTtncTBwcECQFJTUyU2Nta23CJXf27u27ev24d7qtyfntk9P5RURN3+dM3tOXPX3CJq9adn9vJmrlGlP11ze85c5f4sL7eIuv3pmd3ocUXV/nTNXdHMVepPz+yeuVXuT1dGMz9+/Lhcd911bv352GOPSZcuXdzut5XlfqHfX6jS0lIAwIgRIzBq1CjDfVyv5+UpNTUVQNkHGHmqW7eufm1EAEhJSUF2drbXftq1k7VjffLJJ8jNzTU8ZkJCArZv345HHnnE9tyexwLKPkzrjjvuwObNm7FmzRq0adMGERERmDx5MurUqQPAvzM3KyUlBQBw5coVr9vy8/NRu3Zt/UNXVMptloozd7V582bce++9GDhwIN5//319u+q5PaWkpGDVqlUYMmQIALVyv/DCC7h8+TIaN26ML7/8EpmZmTh+/Lh+e25uLi5fvhxwM4+MjMTZs2eVzK0dMzw83PB27cO0VMzuadWqVYiNjdWviQmoef88fPgwTpw4ofeNq4YNG2L79u1K5gbKrqd8yy23YMuWLVi9ejWaN2+O5ORkPP/887b2Z15eHm655Rb9GpyunQ+o259a7tzcXNx2221YvXq1z+OXR8WZu1KpPys786ZNmwKA/nliKs78hRdeQGlpKaKiopCZmQkAeocWFhYiMzMTQUFByuUuj539WdFaUbk/rc5clf6saOaHDx/Gxo0b8dvf/hYnTpzQt2vXFM/KyrI9e3kzj4yMRHJyMjZv3oxTp06hefPmSElJwfnz59G6dWslun/IkCEYP348Dh48iJYtWyrbn0b++9//6rnNUnHmrlTqTyNmZq5Cf3rynLmq/VlR7vKo9vOn61pRuT89VTRzVfrTiOvMVe5PT0Yzr1evHrZt24ZDhw7p/ZmcnIzU1FS0aNGiwmNW5FdxYiExMRExMTG4cuUK+vTpY/nr27VrB6fTafjC+4kTJ5CYmKj/vWPHjti6dSvOnz/v9kHIO3fu1G8Hyj7QA4D+wVquSktLUVJSokRu19s9OZ1OXH/99QCufuCK9oEx/sxuVr169RAWFqY/YXWVnZ2Njh07KpnbLJWzFxUVISMjA9dccw3efvtt/YNiVM9tpLi4GHl5eUrmPnbsGM6dO4d//etfANw/5AsA5s+fj9GjR6Ndu3bKZS9PQUEBEhMTlZx5amoqkpOTcf78eURFRXndHhwcjJiYGERHRyuX3dXJkyexdetWjB49Gq+99pq+XcWZq9aflRESEoIbbrgBQNmHdAH29eelS5dw22234eDBg7j11luxdu1ar69TsT9dc2/ZsgWrVq2y/D01Ks5co1J/VsfMtTWk4syPHTuGy5cv48SJE179uW3bNjRp0gRffvmlcrnLY1d/mlkrqvan1Zmr0p9mZl5efwJXXxBR8f7pqnnz5mjevLn+9wsXLqBPnz5KdH9hYSEA6C+Sqdif5XF9cc8MFbJ7zlyjUn+Wx+zM7epPI54zV7E/zeQuj4o/f2q5Ve1PI+XNXJX+LI+WW9X+NFLezF37c9++fTh58iRGjx5tOaenoCofIQAEBwfjzjvvxNq1a7Fnzx6v23Nycsr9+piYGAwYMAA7duzAgQMH9O379+/Hjh070LdvX33bkCFDcOXKFSxbtsztGMuXL0fXrl3RoEEDANDPCl28eNHr+505cwadOnWyPbf2mxWuuY0UFhbi6aefBgC0bdsWgH9nbkWjRo1QWFion1HUnD17FkOHDlU2txmqZs/Ly8NPP/2Exo0b4/333/f6NHoVc5eUlODy5cuGt/3000+45pprlMw9adIkrF+/Hj179kRiYiLWr1+PpUuX6rf/7ne/Q5MmTZTMfunSJRQXF/u8vX///krmBsrmWlBQgEuXLunbzpw5A6Ds5E5QUJCy2TVvvfUWSktLMXz4cLftKuZu1qwZgLL+9Hxyd/ToUb/3Z1WUlpbi8ccfBwBcc801APw78ytXruB3v/sdPvvsM7zzzjtITk72eVyV+tMz929/+9tyj10RVWeuUn+anXlJSQnOnTvntf2LL74AcPU3sVSc+aRJk9z607VDO3TogPXr16NZs2bK5VatP63cP1XrTyv3T40K/Wl25s2aNUNQUBCOHDnitl37zWLtv1f1mWu0F3JCQkIwYcIEv+b+6aefDI+xYsUKREREoE2bNvo2lfrTKLc2R8/cZtidHTCeuUr9aXbmKvan2Zmr1p9mc6vWn1bun6r1p5X7p0aF/jQ7cxX70yh7cXFxuTN3/W98/PHHERkZiQkTJpSbyZQqX0zJT6ryGQsiIqdOnZJGjRpJZGSkTJ48WZYuXSpz586VoUOH6h84XJ69e/dKdHS0pKSkyNy5c2Xu3LmSkpIiiYmJcvz4cbd9hw4dKiEhIfLYY49Jjx49BICEhITIxx9/7Laf9oniGRkZsnjxYpk2bZoAEKfTKQcOHLA199KlSyU5OVkAeOUeOnSotG7dWurUqSPPP/+8tG7dWr/epV0zX7BggcycOVN+//vf69cNmzlzpsycOVNyc3P1/YYMGSJBQUHStGlT+fvf/y5z5swRAFK3bl25dOmS7bnT0tL07K65MzMzpVOnThIXFyddu3bV9wEgd9xxh7IzP3/+vERGRgoAefbZZ2XlypWycuVKfd3v2LFDydznzp2TkJAQiY6OlhdffFGWLFmiPwaFh4fLwYMHbc/ta62IuD8mGn3Ggt3ZjWZ+5MgRcTqdEhMTI/Pnz5f58+fLgAEDBIA0bdpUrly5YntuXzM/deqUREREiMPhkGeeeUb++te/SosWLQSAjB8/XtmZi1xdK507d5bU1FS5cuWK8mtFRKR58+b69ScXLFigP5Y7HA69s1RcK5MmTZIWLVpI7dq1Zf78+dK1a1ev6/76M/vkyZMFgNx2222ycuVK6dOnjwDQH6tdqdSfnrk9s7tSrT/Nzly1/jQ783PnzklUVJQ0a9ZM4uPj9f7U/lseeughZWcu4v0zhec1olXMrVp/Wrl/qtaflVkrKvSnlZk/8MAD+vNZrT/r168vAGT06NG2Zy9v5q1bt5bo6GhZtGiR3qF2PZbfcccd0qtXL5k+fbq88sorehYA8uKLL7odU6X+9Mw9c+ZMiYuLM8ytWn+anblq/Wl25ir2p5V1rlJ/ms2tWn9auX+q1p+VWSsq9KeVmavWn0bZW7VqZZh90qRJMm7cOLf+dDgcsmLFigrzmPGrObEgUvZBGhMnTpQGDRqI0+mU5ORk6d27tyxbtsxUhq+++kr69OkjUVFREhMTI7fffrv+AqOrwsJC+eMf/yjJyckSFBQkAGTjxo1e+40YMULi4uKkTZs2EhERoX8gsusDgV25w8LC9A+Y9DRv3jz9g7Xi4+Nl0KBBsmvXLltn3uh/n9xu9OfIkSP6fqNGjZLU1FTp16+fREZG6g8af/jDH5TOvXXrVp/7ea59lbK7vqht9GfUqFFK5i4qKpLWrVuL0+mUWrVqidPp1L9u8uTJys5bY+bEgmrZz507J2lpaRISEiKRkZESFhYm6enpAkCeeuopZXNrBg8eLJGRkVKrVi2JiIjQP7xX5ZmLXH1MBCCPPvqoiNjbn2Zzjxw5UmrXri0dO3aU6Oho/UMq7733XqVzL1++XOLj48XhcEhMTIz07t1b/vOf/9g285tuuqncx2hXKvWnldyq9afZ7Kr1p9ncRUVFMnnyZH2da/05ZsyYgFnnFb0wolpu1frTyrxF1OrPyjwmqtCfVnIXFxdLly5dxOl06v3Zs2fPgMh+3XXXidPp1I/Xu3dv23KvXr1a+vTpI0lJSRISEqL/kt2//vUvr+Op1J+euePj4/UXxjyp1p9mZ65af5qduYr9aXWdq9KfZnOr1p9W7p8iavVnZR4TVehPKzNXrT+Nsvfp08dw5suXL5cOHTq49ed//vMfU1nMcIj4uEgUERERERERERERERGRh1/FZywQEREREREREREREVH14IkFIiIiIiIiIiIiIiIyjScWiIiIiIiIiIiIiIjINJ5YICIiIiIiIiIiIiIi03higYiIiIiIiIiIiIiITOOJBSIiIiIiIiIiIiIiMi3E7gCqcTgcPm8TET8msSZQcwOBmz1QcwOBm525/S9QswdqbiBwszO3/wVq9kDNDQRudub2v0DNHqi5gcDNztz+F6jZAzU3ELjZAzU3ELjZmdv/AjV7oOYGAju7J75jgYgCRj2L24mIiIiIiIiIiKj68cQCEQWMjwHU99hW/3/biYiIiIiIiIiIyD94YoGIAkZTAB/h6smF+v/7e1Ob8hAREREREREREf0a8cQCEQWMH3H15MJvcfWkwo/2RSIiIiIiIiIiIvrV4YkFIgoYPXD15MIOXD2p0MO+SERERERERERERL86PLFARAHjOICRHttG/m87ERERERERERER+YdDRMTuEEREpmRlAT16AIcPX92WlgZ89BHQoIFdqYiIiIiIiIiIiH5VeGKBiIiIiIiIiIiIiIhM46WQiIiIiIiIiIiIiIjINJ5YICIiIiIiIiIiIiIi03higYiIiIiIiIiIiIiITOOJBSIiIiIiIiIiIiIiMo0nFoiIiIiIiIiIiIiIyDSeWCAiIiIiIiIiIiIiItN4YoGIiIiIiIiIiIiIiEzjiQUiIiIiIiIiIiIiIjKNJxaIiIiIiIiIiIiIiMg0nlggIiIiIiIiIiIiIiLTeGKBiIiIiIiIiIiIiIhM44kFIiIiIiIiIiIiIiIy7RdxYmH06NFo3Lix2zaHw4Hp06fbksesQM0NBG72QM0NBG72QM0NBG525va/QM3O3P4XqNkDNTcQuNkDNTcQuNmZ2/8CNXug5gYCNztz+1+gZg/U3EDgZmdu/wvU7IGaGwjs7DVJ2RMLDofD1J+PPvrIb5kuX76MOXPmoFWrVggPD0dSUhIGDhyI48ePVzp3UVERrr/+ekRGRiI5OVn/Pv7ObSX7888/j+3bt+PEiRMIDg72umP5O7vZ3Bs3bsSBAwdw+vRppKSkICYmBp06dQIAlJaW+j23lewPPPAAPvjgA2RlZSE8PBzNmzfHlClTqjWzleyVvX/m5uaibt26AIB9+/b5PbeV7B07dsQbb7yBo0ePum2vCTU1c9djAsCqVau85qFK7rfeesvnvP/yl79g7Nixfs1tJft//vMffP/99zhx4gSio6ORlJSEW265pdryWs1uZa2UlpYiNzcXaWlpCAsLQ1paGgB7HhMDtT8/+ugj9qefc1uZOfuzenJbmTn707+5VetPK2uF/Vk9ua1m/+mnn3Dq1Cm9PydNmlStma1kt5L7xIkT+Pnnn9G2bdsa7dBfcn9ayc7+rJ7cVrKzP/2bW7X+tJKd/Vk9uUePHh2w/VlR9uzsbH3ff//73xgzZkyN9WdItR6tGq1cudLt7ytWrMDmzZu9trdu3RqvvPJKtS9CT8XFxRg4cCB27NiBsWPHon379jh37hx27tyJvLw81K9f3yv32bNn8cgjj6C0tBT16tXDs88+65Z74sSJeOutt1BQUIC//vWvOH78OGbPno23334bc+bM8Wtu1+xnz57FY489hpKSEpSWlnrNfMOGDcjKykLnzp2rtSQqm93szMPDw7Fz50706tUL/fv3R61atbBp0yZ88803+Ne//oUZM2b4Nbdr9opmvnr1atxxxx1o2bIl4uPjsX//frzyyisAqveFtJpY5673z2nTpqGgoKDa8lrN7Zq9opkvWrQI9erVw8yZM+F0OvXtI0eOtCW7lZkvWrQIt912G2bPnq0fc8yYMQgNDfWahyq5u3TpguXLl0NEDOfdr1+/Kme2kts1e0Vr5e2338bnn3+Ou+++Gz169EBubi6WLl0KAG6F7q/sVtZKYWEh8vLyMGTIEFxzzTX4/PPPceTIEXzwwQd+f0ycOnUq5syZg379+iEtLQ3btm3Dnj17MGHCBLRv3x4xMTF6btX6E4CeG4CefdGiRXpuQL3+NDtzFfsTMDdz1frTyjpXrT8BczNXrT+tzFyl/jSbW8X+1L5vRWtFtf60slZU6k8AePzxx/Hiiy+icePG6Nq1K3bt2oX9+/djwIABuPvuu/X9rly5gv/85z9o1aoVJkyYgOPHj+OFF16olryVyb5y5Urs3r1bzx4cHIyDBw/i1ltvRWlpqZ69devWSE5ORnFxMWJjY5GamlrtmWsit4r9aXatqNafVtaKav1pduaq9aeVmavUn2Zzq9ifZteKav1pZa2o1J/jx49HRESE29dq3Z+amop58+bp21Xrz/Hjx6NPnz5uXysimDBhAho3box69erp2998802sWbMGv/nNb2qmPyVATJw4UazEBSDPPPNMtX3/efPmidPplJ07d5r+mt/97ndSr149ASDp6elet99yyy2SkpIieXl5+jYAAkA2bdpka+5evXpJamqq4cyzs7Pl8uXLIiIycOBAadSokZ5d5Znn5OTInj17vL5Gm/mhQ4eqnFmkZmZu5N133xUAcuedd1Y2qpeaWOea3bt3S0hIiMyYMUMAyNChQ6sjsojUzMxvuukmw/8e1de5r2MGQm4jACQ0NFQKCwsrG9VNda+V4uJiiYiIkCFDhrhtP3z4sACQLl26VEtukeqf+RdffCEA5Omnn3bbrj0mfvvtt37NvXXrVgEg77zzjoiU3/sq9adn7vKyq9afZmeuWn9ambkRO/vTyjrXqNCfVmauWn9amblK/VmZteLKrv40u1ZU7E+zM1etP/Py8iQpKUkyMjLkypUr5WY36s9XXnlFAMiIESOqJXdVspe3zo061K77p9ncqvWnlbVixM7+tLJWNCr0p5WZq9afVmauUn9WZq24sqs/za4VFfvT7MxV608jgwcPFgAye/Zst+2q9aeRTz/91DC7r59Bq4uyl0Kywug6V0ays7Nx//33IykpCWFhYUhPT8drr71W4deVlpZi/vz5yMjIQJcuXVBSUlLhWe9PPvkE7777Lm644QbD28+fP4+NGzfi4sWLqFWrltttTqcTb7/9tq25X3rpJZ/7pKamYuzYsQE384SEBDz//PM+c+/fv9/W3OXNHPBe59r/v3Tpktt+Ks3cNffkyZORkZHhc18VZ56dnY3GjRvjwoULFe6nysxLS0sxffp0OJ3OCo+pUm7Ae42fPHkSQNlvNmhvp7Urt6+1UlxcjMLCQuzZs8ctu/aWa9fffrEru6+Zf/rppwCAV1991fD2NWvW2JIbAPLz832+E1HV/tRyl5SU+Lxd1f7Usvuauar9qeUub+aAmv2pZS/vHbcq9qeWu6KZq9ifWnZfM1e1PyvKDajZn1puX2tF5f7UsvuauWr9+eabb+L06dOYPXs2goKCcPHiRYiI137nz5/H5s2bUbt2bbRv317ffu+99wIA9u7d67a/HdmLi4t9Hnfq1Klo3rx5hd9fpdyq9afZtaJRqT+trBWV+tPqzFXqT7MzV60/K7NWNHb2p9m1omJ/mp25av1p5ODBgwCAe+65R9+mYn8aefPNN+FwONyyA2U/g3qui+r0izixYMbp06fRrVs3bNmyBQ899BDmz5+PZs2aYcyYMRW+uLhv3z6cOHEC7du3x7hx4xAVFYWoqCi0b98eW7du9dr/ypUrePjhh/HAAw+gTp06hsfcvXs3RARhYWFetyUnJ2PXrl225m7Xrl25xzZDtZlXJCEhwdbcZmZeWlqKU6dO4dNPP9Wv5+ZaJqrOvKCgADt27MBzzz1neLuqM8/Ly8PRo0cRExOD5ORkPP3008pk9zXzffv2obCwEKGhoW7HBIAjR44om9vIW2+9BQBu5a3aWomIiEDXrl3xww8/4OLFizh27Bi+++47jB49GgDQuXNn27P7mnlRUREA+Lx261dffeX33ABw3333oVatWliyZAkA4Msvv3S7XcX+dM0dHh6O9evXl3v8iqg284rY0Z+uuc3MXKX+dM1e0cxV6k/X3BXNXLX+dM3ua+Yq9qeZ3Ebs7k/X3L7Wiqr96Zrd18xV688tW7agVq1ayM7ORsuWLREdHY1ly5YBcH8BePfu3SgpKdEfszWhoaEArr6gZmd2Lffvf/97rxevzQi03P7uT7NrxZUq/Wl15qr0p9WZq9SfZmeuWn9W5f5pZ3+aXSsq9qfZmavWn56Ki4tx6NAhAO6Pcyr2p1H2t99+G927d6/Rz/EzVK3vf6hB5b19adSoUV5v5YDH267GjBkjKSkpcubMGbf9hg0bJrGxsVJQUODze69bt04ASJ06daR58+ayfPlyWb58uTRv3lxCQ0O93q7z8ssvS2xsrPz00096bs+3tL3zzjsCQJKTk71yt2nTRt9uV24RKfeyPNrMy7uUg2ozd82tKSoqEgASFxcnxcXFtuYWKX/md911l/4WMQBSv379gJj5iBEjJDg4WP785z+LyNW3mbu+FVXFmd9///3SoUMHSUxMlBUrVsigQYP02as8c+2YQUFBbsfUtmnHVC23iPf9s3PnzgJApk2bpm9Tca0cOnRIateu7Xb/TEtLU36trF27VgBIQkKC23btv6Ft27Z+zb19+3a588475dVXX5V//etf0q1bNwEg4eHh8vXXX+v7qdafnrnnzp0rYWFhAsAtt0al/jQ7c9fcGjv70+rMVepPKzNXqT+tzFy1/jQ7c9X6syr3Tzv708paUa0/zc5ctf5s3769REZGSmRkpDz88MOydu1aadeunQCQYcOG6ftp/dm/f3/Dn52joqL0v9uVvX///vocXbOLuK9zX5dCUj23iL39aXataFTqTyszV6k/rcxctf40O3PV+rMq9087+9PKWlGtP83OXLX+9LRhwwY9iysV+9NX9kWLFvncR6RmLoX0qzixUFpaKnFxcTJu3DjJyclx+6M94G3bts3n916xYoUAZddZO3bsmL796NGj4nQ6Zfjw4fq2M2fOSO3ateWFF15wy+35go52zJSUFK/c7du3l9jYWFtzi1TtxIKKM3fNrRk7dqwAkHvuucf23CLlz3zkyJGSlJQkGzZskBkzZkjHjh0DYuYdOnSQ4OBgyc/PFxHvJ3Yqz9zXehkzZozt2St6bAHgdkztid3w4cOVzO057++//97ribSqa+XUqVOSlpYmMTExsm7dOlm0aJE0bNhQAMhjjz1me3ZfMy8sLJSoqCgJCgqStWvXSmZmpqxZs0YAiMPhkKZNm/o1tyctd0REhNx8881ex1SlP42MGDFCALjl1qjUn558zdw1t8bO/jRS3sxV6k9P5c1cpf40Ymada+zsT08VPbao0p9mc4uo1Z9GfK0V1frTk6+Zq9af2otJEyZM8MoOQA4ePOh2TKMXFQBIWFiY32fumV3LPX78eLfsIhWfWAiE3CL29qfZtaJRqT+tzFyl/rQ6c5X60+zMVevPyt4/7e5PK2tFtf40O3PV+tPT3XffLUFBQV4/86vYn0bZnU6n1wkNTzyxYPCCjkjFJxZOnz6t3xl9/Vm3bp3P762dnerZs6fXbT179pQmTZrof58wYYI0a9ZMioqK3HJX5h0LduYWqdqJBRVn7ppbROS5557zKo5AmLlm+/btAkDuvvtu27P7mvmRI0ckODhY6tSpo2/zfGIXSDM/cOCA2/dScebaMcPDw922A5DGjRtLkyZNlMwt4j7vadOmBcT9s7i4WNq2bSutWrVyWysHDx4UANK9e3fbs5c389tvv12cTqeeQfut0sjISOnQoYNfc3vScg8bNkxCQ0OlpKTE7Ziq9Gd52V1za1TqT1+5PWfumlvE/v4sL3t5M9fY2Z++cnvOXLX+LC+7mZnb2Z++cvt6bFGlP83mFlGrP8vL7ppbxf70ldto5ir1Z3p6ugCQjz/+2Cs7AHnjjTfcjlnRb1zamV3L/fHHH7tlF6n4xEIg5La7P82uFaPsIvb2p9mZq9afVZ25nf1pduaq9Wdl759296fZtaJif1qZuUr96So/P18iIyP1bjE6pkr9aZT91ltv9XlsTU2cWAjBr4D2wVsjRozAqFGjDPdxvYaap9TUVABAUlKS121169bVr+d86NAhLFu2DC+99BJOnDgBoOxDPoCy611lZmaiVq1aqF27NlJSUgCUXQfbU35+PlJTU23N7ZrNNbdZKs7c1euvv44nnngCEyZM0K+fanduwNrMu3fvDgD47rvvbM/ua+bTpk1DZGQkwsPDkZmZCQA4deoUAODixYvIzMzUr0sXCDNv0KABAKCwsBCAmjPXjhkU5P0ROlFRUcjOzlYyt6c333wTLVu2xPfff69vU/H++cknn2DPnj3o27ev/kFPAPQPF8zKyrI9e3kzj4uLQ2pqKj744AOcO3cObdq0QZ06dVBQUIAWLVr4LXd5GjRogMuXL+sf1qxSf1bENbdZKmT3nLkru/uzImZmbld/lsdz5ir1Z0XMzNyu/iyP58xV6k8ruT3Z2Z8Vcc2tWn+Wx2jmKvVnamoq9u7da7gvAJw7dw4A9P7U7oeeYmJiAPh35r6yax9CqmU3Q/XcKvSn2bXii539aXbmqvVnVWduZ3+anblq/VnZxxW7+9PsWlGxP63MXKX+dPXPf/4TBQUFaNmyJY4ePep2m4r9aZR9+PDhPo9dk34VJxYSExMRExODK1euoE+fPpa/vl27dnA6ncjOzva67cSJE0hMTAQA/QFz0qRJ+gcbaQ4ePIgmTZpg8uTJeOmll9C2bVs4HA79w0tcnTp1Cn379lUiNwC33GapkN1z5pqCggI88MADGDx4MBYuXOj2xE6F3IC1mWtrSIXsnjM/duwY8vPzkZ+fjyZNmrjt++GHH6JJkyY4c+aM7bkBczM/fPgwACAyMhKAmjNv164dHA6HzxddExMTlcztaufOnfjhhx8wY8YMTJs2Td+uQm7Afa2cPn0aACAiht9Te3KhQvbyZp6enu513D59+vgtd3kOHz6M8PBwREdHA4BS/VkR19xmqZDdc+YaFfqzIlZm7u/+LI/nzFXqz4qYmbld/VlRJtfsKvWnldyu7O7PirjmVq0/y1PezFXoz86dO2Pz5s36h2Z60vZt27YtQkJCcObMGbfbL1++DABITk7W97c7u/bLEWbXluq5VelPs2ulInb0p9mZq9afVZ25nf1pduaq9WdlHldU6E+za0XF/qzMzFXoT1erVq1CdHS01+MGoGZ/GmUfNGiQ5e9ZHbxPKf4CBQcH484778TatWuxZ88er9tzcnLK/fqYmBgMGDAAO3bswIEDB/Tt+/fvx44dO9C3b18AZYtt/fr1bn9uueUWAEDDhg2xfv16jBkzBgAQGxuLlJQUXLx4Efn5+W7fr7i4GEOHDrU19/r16/XfaHXNbZaKMwfKHoRzcnJw4403YtWqVV5n1VWc+cWLF1FQUOD1vdauXQvg6llNFWc+a9Ys9OzZE4mJifq+M2fOBFD2Gy/r169HrVq1lJv5+fPnvV60FBHMmjULANCsWTMAas48JiYG9evXR1FRkdsxgbLfXujbt6+SuV29+eabAIB77rnHbbuK988WLVoAAI4cOeL2vb7++msAV59kqD5zjfZbGNHR0bj77rv9lru8Y7333nvo16+f/nitUn/6Opb2pNM1t1l2Zwe8Zw6o05++jmU0c9X6s7xjec5cpf70dSyjmavWn+Udy3PmKvWnldyu7O5PX8cyWiuq9Wd5xypv5ho7+/Ouu+4CALz66qtexwkJCUGPHj0AlPVnnz59cPjwYbcXpFauXAng6os8KmT/xz/+4ZbdDFVzq9SfZteKiv1pduaq9afZmavYn2Znrlp/VuZxRYX+NLtWVOzPqjyW29mfrsfcsmULMjIyEBLi/fv3KvanUXbtBKTfVeuFlWpQVT5jQaTsw00aNWokkZGRMnnyZFm6dKnMnTtXhg4dKvHx8RV+/71790p0dLSkpKTI3LlzZe7cuZKSkiKJiYly/PjxCnMbXdv61ltvFQDSqVMnWbx4sTz55JMClH2au925RXxfe/7bb7+VTp06SVxcnLRs2VLi4uJk5syZArh/4rtqM8/MzBSn0ykOh0MWLlwoK1eulJUrVwoAycjI0D9hXbWZ79q1S+rUqSMtW7aU2rVry8svvyyjR4+WkJAQAa5+OI+d2a18YLbnNS7tzC1iPPOtW7dKcnKytGnTRv8Q3Ouuu06/Lp7qjy233367OBwOt2Pif9ct1I6pYm5trSQlJUm3bt1ERJ3HchHfj4l9+/bV57t48WKZNm2axMfHCwCZOHGi7dnLm3mjRo0kJiZGli5dKs8//7y0bt1aAMjIkSP9nrtnz54yYMAAmTVrlixbtkw6dOggACQ2Nlb27dvndkyV+tMz95QpU/THZ8/cqvWn2Zmr1p9mZ65if1pZ5yr1p9mZq9ifVmauUn9WZq2o0J9WHhNV608rM1epP0VE7r//fgEgd911lyxcuFCaNm0qAOTPf/6z235fffWVBAUFSWhoqN6f4eHhtj7fcs1+44036o8XntkHDRqk96bWofjftajfe+89JXOr1p+euX2tFRX70+zMRdTqT7MzV7E/rcxcpf60klul/vTMXd5juWr9aWXmqvWniMiCBQsEgGzcuNHna88q9qdndl++/fZbmTlzplt/an/X+rMqfjUnFkTKPkhj4sSJ0qBBA3E6nZKcnCy9e/eWZcuWmcrw1VdfSZ8+fSQqKkpiYmLk9ttvd/tk9vJy+3oRLTk5Wbp37y7h4eGSmJgoAORPf/qT7blFfL+Ipn2audGfDh062J7d18y1JxS+/riuF5VmnpOTI+PGjZNatWqJw+GQ0NBQad68uUyZMiVg1nlFT+zsyi1iPPPDhw/L0KFDJSoqSi/szp07y5IlSwJm5ikpKW7HBCAPPfSQ8rnr1q0rAOTvf/+7iKjzWC7i+zGxoKBAOnbsKE6nUyIiIiQ2NlZ/4VuF7OXNvHPnzhISEiLh4eESHx8vgwYNsi33/PnzpUuXLlK7dm0JCQmRyMhIASCHDh3yOp5K/emZOyUlRVq0aBEQ/Wl25qr1p9mZq9ifVte5Kv1pduYq9qfVmavSn1Zzq9KfVh4TVetPKzNXqT9FRC5fvizTp0+XRo0aidPplNjYWJ8/O/fv31/CwsL0/tSeJ6iQPSgoSADI3/72N6/9XF9k9fwzatQoJXOr1p+euX2tFRX70zN7eWtFpf70zO1r5ir2p2f2imauSn9aza1Kf3rmLu+xXLX+9Mxe3sxV608RkW7dukndunWlpKSk3NeeVetPz+y+lPczqGt/VpZDxMeFuYiIiIiIiIiIiIiIiDz8Kj5jgYiIiIiIiIiIiIiIqgdPLBARERERERERERERkWk8sUBERERERERERERERKbxxAIREREREREREREREZnGEwtERERERERERERERGQaTywQEREREREREREREZFpIXYHUI3D4fB5m4j4MYk1gZobCNzssQ4HYgBkG9ymcm4gcGfO3P4XqNkDNTcQuNmZ2/8CNXug5gYCNztz+1+gZnfNXR/ARwB+AtAfQJ7CuYFfxsw9MXfNCNTsgZobCNzsgZobCNzs9R0Ow9dY6gE4rnDuQJ03ELjZAzU3ENjZPfEdC0SVtBHAxyj7ocuV59+JiIiIiAJBfZf//QhAUwB1AcTYFYiIiH5VfL3G8rENWYioYjyxQFRJdVH2w9ZH8P4hjIiIiIgo0HwTF4ff4upJhR8B9IDxO3SJiIiqm6/XWJralIeIyscTC0SV1ANlP2xpxfdbAJ8GBbHwiIiIiCgg1cnNxQ64n1Q4bmsiIiL6NfF8jeUjXO0kIlIPTywQVdJxuJ9c2AGgcWkpDpdzrTQiIiIiokAwEjypQERE/tUD7q+xuJ7oJiL18MQCURUcR9kPXa5GBNgHrRAREREReVoJfnYYERH5l9FrLDzRTaQuhwTax00TqSQrC+jRAzh8+Oq2tDTgR75Rj4iIiIgCTNOmwMqVwMiRZc9v09KAjz4CGjSwOxkREf0a+HqNhV1EpCSeWCAiIiIiIiIiIiIiItN4KSQiIiIiIiIiIiIiIjKNJxaIiIiIiIiIiIiIiMg0nlggIiIiIiIiIiIiIiLTeGKBiIiIiIiIiIiIiIhM44kFIiIiIiIiIiIiIiIyjScWiIiIiIiIiIiIiIjINJ5YICIiIiIiIiIiIiIi03higYiIiIiIiIiIiIiITOOJBSIiIiIiIiIiIiIiMo0nFoiIiIiIiIiIiIiIyDSeWCAiIiIiIiIiIiIiItN4YoGIiIiIiIiIiIiIiEz7RZxYGD16NBo3buy2zeFwYPr06bbkMStQcwOBmz1QcwOBmz1QcwOBm525/S9QszO3/wVq9kDNDQRu9kDNDQRudub2v0DNHqi5gcDNztz+F6jZAzU3ELjZmdv/AjV7oOYGAjt7TVL2xILD4TD156OPPvJbpsuXL2POnDlo1aoVwsPDkZSUhIEDB+L48eOWc2/cuBEHDhzA6dOnkZKSgpiYGHTq1AkAUFpa6vfco0ePNp39gQcewAcffICsrCyEh4ejefPmmDJlSrVmtpK9smslNzcXdevWBQDs27fP77mtzLxjx4544403cPToUbftNaGmZu56TABYtWqV2zH9kdvKzB0Oh8+Zv/fee9WW22x2KzMXEeTn56Njx46Ijo5GUlISACArK0vp3KWlpcjNzUVaWhrCwsKQlpYGwJ7HRKvZf/rpJ5w6dQqRkZFITk7GpEmTqjWzlexWcp84cQI///wz2rZti+DgYK8nSirmVq0/rWRnf1ZPbivZ2Z/Vk9tKdvan/3OzP6sne6D2p5XskydPxr///W9kZWXp/bl48WLbsluZ+XfffYeTJ08iMTFR71AAuHjxotK5XbE/K5+d/cn+rIncNd2fmZmZ5WYYO3as2/4q9aeV7Cr1Z03N3B/9aTV7UVERnnjiCaSmpiIiIgJdu3bF5s2bvY47Z84cdOvWza0/p0yZgpycnGrJHVItR6kBK1eudPv7ihUrsHnzZq/trVu3xiuvvFLtT5w9FRcXY+DAgdixYwfGjh2L9u3b49y5c9i5cyfy8vJQv359AMC0adPw008/6V+3bds27NmzB6GhoUhISMC8efMAAOHh4di5cyd69eqF/v37o1atWti0aRO++eYb/Otf/8KMGTP8mnv8+PGIiIhw+1ote2pqqp4bAFavXo077rgDLVu2RHx8PPbv349XXnkFQNkDfXWp7pl7rpVp06ahoKCg2vJazW1l5osWLUK9evUwc+ZMOJ1OffvIkSNtyW5l5osWLcJtt92G2bNn68ccM2YMQkND3Y7pj9xmZ15UVIRLly4hKioKIqLPfOPGjVi1ahWaNm1a5cxWs1uZeXx8PM6ePYsBAwbgwQcfRG5uLp544gksX74c48ePR5cuXZTMXVhYiLy8PAwZMgTXXHMNPv/8cxw5cgQffPCB3x8Ts7KyEBkZiYiICPTu3RtRUVHYtGkTTpw4gU6dOuHRRx/Vj3nlyhX85z//QatWrTBhwgQcP34cL7zwQrXkrUz2l156CVOnTtWz7969G/v37wcAt+ytW7dGcnIyiouLERsbi9TU1GrPXBO5VetPK2tFtf60slZU6k8rM1etP63MXKX+NDtzFfvTysxV6k8ruVXqz6+//hpOpxO1a9dGr169ICL45z//iUuXLuG5555DSkqKfkzV+nPmzJmYMWOGnv3LL7/EoUOHEB4ejhkzZujZVetPszPPysrC1KlT0atXLzz88MOoXbs2Nm3ahAcffNC27FZm3qhRI3Tu3Bnp6emIiYnB/v378eKLL+LVV1/F9OnTERUVpWRulfrTyv1Ttf60MnOV+tPszFXsTyszV6k/reSu6f5MTEz0eg0TuPrv2q9fP7ft3bp1wxdffIH+/fsjKSkJ69atQ15eHp566im0bNlS388f/Wkl+8qVK7Fw4UI9+5EjR7B//34EBQVh6tSpenZ/9GdNzNxf/Wk1++jRo/Huu+9iypQpaN68OV5//XUMGDAAW7duxfXXX6/v99VXX6Fjx44YNmyY3p+vvPIKPvjgA3zzzTdV708JEBMnThQrcQHIM888U23ff968eeJ0OmXnzp2Wvk7LDUBmz56tb8/JyZE9e/Z47a/te+jQoSpnFql8bhGRwYMHe+X25d133xUAcuedd1YmpqHqnrmr3bt3S0hIiMyYMUMAyNChQ6sjsojUzMxvuukmSU9P99pf9XXu65iq5Baxts579+4tAOTJJ5+sTExD1T3z4uJiiYiIkCFDhrjtr+07adIkJXN/8cUXAkCefvppw9zffvutX3PPnj1bALg9TrtmP3v2rL79lltukZSUFMnLy9O3vfLKKwJARowYUS25q5Jdy33vvfd6Zc/OzpbLly+LiMjAgQOlUaNGtt0/zeZWrT+trBUjdvanlbWiUaE/rcxctf60MnOV+rOq69zO/jQ7c9X602xu1fpzwIABEh8fL2fOnNG3jR49WgDI4MGD3fZVrT89s2szj46O9squUn+anbmv/rzvvvsEgDz88MO2Zy9v5ka0db569Wrlc6vQn1bun6r1p5WZq9SfVmZuxM7+NDtz1frTbG5/9aeR3r17S61ataSwsFDftnPnTgEgzz//vL5t/PjxAkB++9vfun29v/qzstm1mTdt2tQruz/6s7K5RYxn7s/+rEr2wsJCw5kb0X4GrY7+VPZSSFYYXefKSHZ2Nu6//34kJSUhLCwM6enpeO211yr8utLSUsyfPx8ZGRno0qULSkpKLP+mgcPhwD333KP/PSEhAc8//7zP3NpvJNmZ++DBgwDgllvjOXPt/1+6dMltP5Vm7pp78uTJyMjIwA033GD4tSrOPDs7G40bN8aFCxfKPYZKMy8tLcX06dPhdDorPKaKM3dd5ydPnsTWrVsBACEh7m/2UmnmxcXFKCwsxKZNmwz3d33Hhkq5P/30UwDAq6++arj/mjVr/Jr7/PnzAKC/jddVUFAQQkND9f02b96M2rVro3379vo+9957LwBg7969bl9rZ/aUlBS37AAwdepU/VIC5VEpt2r9aXataFTqTytrRaX+tDpzlfrT7MxV68+qrHO7+9PszFXrT7O5VevPTz/9FH369EGdOnX0bdpvwr3//vv6/VDF/jTKDgA33XSTW3ZArf40O/OEhASkp6d79VBGRgYAeF0SQbWZl/czf25urvK5VehPs2vFNZMq/Wl25qr1p9WZq9SfZmeuWn+aze2P/jSi/bsOHjxYv0wXALz77rsIDg7GuHHj9G3av/tnn32mX1bKX/1Z1ewAMGbMGLfsQM33Z1VzG83cX/1Z1ezh4eGGMzei/Xe49mdl/SJOLJhx+vRpdOvWDVu2bMFDDz2E+fPno1mzZhgzZgxeeumlcr923759OHHiBNq3b49x48YhKioKUVFRaN++vf5A74v2tsfu3btbunZYQkKCrbmLi4tx6NAhAPCZu7S0FKdOncKnn36qX8/NdV9VZ15QUIAdO3bgueeeM/x6VWeel5eHo0ePIiYmBsnJyXj66aeVye5r5vv27UNhYSFCQ0PdjgkAR44csT23mXWueeuttwwvuabazCMiIpCQkIALFy5g1apVOHbsGL777jv9Nq14VMtdVFQEAD6v3frVV1/5NXePHj0AlD0Z+uabb5CVlaWvlUmTJunrePfu3SgpKdEfszXaCz4nT57Ut9mVXXvyvHjxYrfsZgVabn/3p9m14kqV/rQ6c1X60+rMVepPszNXrT8rs841dven2Zmr1p9mc6vWn0VFRV6XndRcvnwZe/bsAaBmf/rKHhkZ6ZbdLLtzAzCV+9SpUwDK/jtVyV7ezM+cOaN3KFC29rX7i6q5VelPq2tFpf40O3PV+rMq90+7+9PszFXrT7O5/dGfRrR/1+HDh7tt37VrF1q0aIFatWoZft0333wDwH/9WR3ZtUtgadnNsju3pqLc1d2f1ZHd18xFxK0/J02ahODgYL0/q6TK73nwk/IuhTRq1Chp1KiR2zZ4vJVmzJgxkpKS4vYWNBGRYcOGSWxsrBQUFPj83uvWrRMAUqdOHWnevLksX75cli9fLs2bN5fQ0NBy3yI1cOBAASCLFi2qMHdRUZEAkLi4OCkuLrY194YNG/S3gBm566679NsBSP369QNi5iNGjJDg4GD585//LCIiW7du9Xorqoozv//++6VDhw6SmJgoK1askEGDBun7qjxz7ZhBQUFux9S2acdUceYi7vfRzp07S0pKivIzFxHJyMiQ0NBQt/soAJk4caKyudeuXSsAJCEhwW27lr1t27Z+zz1z5kyJiIjwmqOrd955RwBI//79DXsoKipK/7vd2Y3eQu26xn29FVX13CL296eZtaJRrT/Nzly1/jQ7cxX708zMVexPK+tctf40u85V608zuVXrz3bt2kmLFi2kpKRE3zZhwgQ9z7vvvisiavanZ3bt58+GDRu6ZRdRqz/Nztwoe1FRkbRp00YA98uBqDpzrTNd/7hefkXF3Cr1p5W1olp/mp25av1Zlfun3f1pZZ2r1J9mc/ujP41o/65Xrlxx256eni69evVy2+Z62cklS5aIiP/6syrZtdx79+51yy5S8/1Zldyu2T1ze2avif6sanYRMZy5iMjJkye9fgZds2aNpSy+/CpOLJSWlkpcXJyMGzdOcnJy3P5oJbNt2zaf33vFihUCQEJDQ+XYsWP69qNHj4rT6ZThw4f7/NrmzZsLAK9FZZR77NixAkDuuece23PffffdEhQU5HPmI0eOlKSkJNmwYYPMmDFDOnbsGBAz79ChgwQHB0t+fr6IeD+xU3nmvtbLmDFjbM/ua+baMQG4HVN7Yjd8+PCAmPn3338vAOSRRx4JiHV+1113SVRUlEycOFHWrVsnixYt0p+I5eTkKJm7sLBQoqKiJCgoSNauXSuZmZmyZs0aASAOh0OaNm3q99wrV66Um2++WZYtWyZr166V1q1bCwBZsGCB1zG1J0WuAEhYWJiI+H+tuGbv37+/PkfX7CIVP7ELhNwi9venmbWiUa0/zc5ctf60MnPV+tPMzFXsz8rMXJX+NLvOVetPM7lV68/FixcLABk1apTs3btXdu/eLc2aNdPX88qVK92OqVJ/emYfNmyYABCn0+mWXUSt/jQ7c6Ps2uOhKtnNzHzz5s16hwKQQYMGKZ1bpf6syloRsbc/zc5ctf6s7MxV6E8r61yl/jSb2x/96cn139VTWlqa3HLLLW7bXF/k/tvf/uY2i5ruz6pk13L/+OOPbtlFar4/q5LbNbtnbs/sNdGfVc0uIoYzFyk7EeLanx07dpRXX33VdJby/CpOLJw+fVr/B/f1Z926dT6/t3ZGsGfPnl639ezZU5o0aWL4dfn5+RISEmIq93PPPee1KO3MHRkZqd/BK8ouIrJ9+3YBIHfffbft2X3N/MiRIxIcHCx16tTRt3k+sQukmR84cMDte6k4c+2Y4eHhbtsBSOPGjaVJkyYBMfNp06YJAPnyyy+VuY/6mnlxcbHExcVJTEyM23btyfTjjz+uZG4Rkdtvv11/wqc9KQIgkZGR0qFDB7/mXr16tUREREhWVpa+TeuhyMhI/cSI2d8YsTO7lnv06NFu2UUqfmIXCLnt7k+za8Uou4i9/Wl25qr1Z1Vnbmd/mp25av1Z2Zmr0J9mZ65af1p5TFSpP0VEpk6d6pYnMTFR///r1693O6ZK/WmUHSh7l4hrdhG1+tMot9HMPbNr/Tlz5kylspuZuUbbf8OGDUrmVq0/jXKbWSsau3/+NDNz1frTKLeZmavQn0bZjWauWn+azS1S8/3pyfXf1VN1v2PBzuxVeceCijP3zF5T/VnV7CK+37HgSfsZdMOGDabz+OL+CTC/UNp16UaMGIFRo0YZ7uP6oSeeUlNTARh/YF3dunWxa9cuw6/75z//iZKSkgrzvf7663jiiScwYcIELFmyRIncBQUFaNmyJY4ePVphfqDseukA9GvpqTjzadOmITIyEuHh4cjMzARw9ZpoFy9eRGZmpn5dukCYeYMGDQAAhYWFANScuXbMoCDvj3OJiopCdnZ2QKzzN998Ey1btkTnzp3dtqs4808++QS5ubmGx0xISMD27dvxyCOPKJcbAOLi4pCamooPPvgA586dQ5s2bVCnTh0UFBSgRYsWfp33okWL0KlTJ9SvX99r34KCAuzatQt9+vRBSkoKgKv3Q08xMTEA/LtWfGUfNGgQXn/9dT27GarnVqE/za4VX+zsT7MzV60/qzpzO/vT7MxV68/KzlyF/jQ7c9X608pjokr9CQCzZ8/GH//4R+zduxexsbFYunQpFi5cCABo0aIFACjZn57ZFy5c6HaNcy27GSrO3NWFCxf0/nzqqafcrp0faDOPjo7GqlWrcM011yiXW7X+9MxtZq24svvnTzMzV60/PXObnbkK/emZ3dfMVetPs7mBmu9PT77+XYGyXszOzvb5tdoM/NWf1ZFd+7wHLbsZKuTWGOWuyf6sjuxmZ969e3ekpKRg1apVuPXWW01nMvKrOLGQmJiImJgYXLlyxfSLKa7atWsHp9Np+I924sQJJCYmGn7dqlWr4HQ6UVxc7PPYBQUFeOCBBzB48GAsXLjQ7YURO3NHR0ejSZMmlr+n9gE4Ks782LFjyM/PR35+vtd/24cffogmTZrgzJkzATPzw4cPA7j6QTEqzrxdu3ZwOBy4cuWK1235+flITExUfp0XFRXh6NGjmDFjhtdtKs789OnTAAAR8bqttLQUJSUlSuZ2lZ6e7rWtT58+fs19+vRpxMfH+zyWdoKkbdu2CAkJwZkzZ9xuv3z5MgAgOTkZgH/Xiq/s2tzNnPDWqJxblf40u1YqYkd/mp25av1Z1Znb2Z9mZ65af1Zm5qr0p9mZq9aflXksV6E/NfHx8bj++uvdttWvXx+tWrUCoGZ/emZ/6623AABbtmxxy26GijPXHDt2DD///DPuvPNO/cVNVbJXZuYlJSXIy8tTMrdq/emZ25WZeavw82dFM1etPz1zu/I1c1X60zO7r5mr1p9mc7uqqf50tXPnTvzwww+G/64A0LFjR2zduhXnz583/DDhjh07AvBff1ZH9p07d7plN0OF3K63u6rp/qyO7FZmfunSJeTl5VUpJwB4n8b9BQoODsadd96JtWvX6p8A7yonJ6fcr4+JicGAAQOwY8cOHDhwQN++f/9+7NixA3379jU85pYtW5CWlubzuKdPn0ZOTg5uvPFGrFq1yuusup25MzIyEBLifd7p4sWLKCgo8Nq+du1aAFfPiqk481mzZqFnz55ITEzE+vXrsX79esycORNA2dm69evXo1atWsrN/Pz58/oLThoRwaxZswAAzZo1A6DmzGNiYlC/fn0UFRW5HRMAsrKy0LdvXyXXuauLFy8CAO655x6v21ScufYbGFpuV2fOnEGnTp2UzG1E+y2M6Oho3H333X7N3aJFC+zatQsHDx70Ok5QUJD+mwaxsbHo06cPDh8+7PZkeuXKlQCuPklVIfvq1avdspuham6V+tPsWlGxP83OXLX+NDtzFfvT7MxV60+zM3elSn+anblq/VmVx3I7+9PIoUOHAABTpkzRH69V7E9f/vvf/7plN8Pu3EYzB8p+s/jjjz9GeHi4YX+qkB3wnvnFixd9njS+dOkSrrnmGiVzq9afRozWior96YvnzFXrTyO+7p8aVfrTF8+Zq9afZnMbqe7+dPXmm28CMP53BYAhQ4bgypUrWLZsmb5NO0HWtWtX/R1D/urPqmYHgOXLl7tlN8Pu3EYzB/zTn1XNXlRU5DXz8n4GPXfunP5uvyqp8sWU/KQqn7EgInLq1Clp1KiRREZGyuTJk2Xp0qUyd+5cGTp0qMTHx1f4/ffu3SvR0dGSkpIic+fOlblz50pKSookJibK8ePHvfZfsGCBAJDbbrvNMHdmZqY4nU5xOByycOFCWblypaxcuVIASEZGhv6p9nbl3rhxo+HMd+3aJXXq1JGWLVtK7dq15eWXX5bRo0fr101/7LHHlJ25iPda8bzGpZ25fc1869atkpycLG3atJHatWvLCy+8INddd51+jTaV17lI2XULHQ6H2zHxv+sWasdUbeaae++9V4KCgqRbt276tkCYeUpKiv5YsnjxYv3afE6nUw4cOKBs7kaNGklMTIwsXbpUnn/+ef2DQUeOHKnv46/cH3/8sQQHB0vdunVlxowZsnDhQmnYsKEAkAceeMDtmF999ZUEBQVJaGioLF68WJ588kkJDw+3ba14Zr/xxhv1xwvP7IMGDZK4uDiZOXOmtGzZUuLi4gT/u37pe++9p2Ru1frT7FpRsT+trBWV+tPszFXsTyszV6k/rTwmiqjVn1ZmrlJ/WsmtWn/27t1b5s2bJ//4xz/kgQceEIfDIQCkuLjY7Zgq9qdr9jZt2gj+dx1rz+yq9aeZmWdmZkpsbKwEBwdL7dq19f7UOnTChAnKznzXrl0SFhYmMTEx8ve//13vUAASGxurf+aIarlF1OtPM2tF1f40O3PV+tPsY6KIev1pduaq9afZ3P7oTxGRkpISSUpKcvt3NTJ06FAJCQmRxx57TJYuXSrJyckCQD7++GO3/fzVn5XN3qNHDwEgISEhXtn90Z+Vze1r5v7sz6pk7969u9fMtZ9BH3zwQbf+DAkJkcaNG3t9Tlpl/GpOLIiUfZDGxIkTpUGDBuJ0OiU5OVl69+4ty5YtM5Xhq6++kj59+khUVJTExMTI7bffLgcPHjTct1u3blK3bl158MEHDXNrTyh8/XHNbkfukpISw5nn5OTIuHHjpFatWuJwOCQ0NFSaN28uU6ZMUX7mIuae2NmV29fMDx8+LEOHDpWoqCj9CVHnzp1lyZIlATPzlJQUt2MCkIceesj23L5mrunTp48AkL///e/6tkCY+YgRIyQuLk7atGkjEREREhsbKwBk/PjxSufu3LmzhISESHh4uMTHx8ugQYNsnffOnTvllltukeTkZHE6nfocjX4I6N+/v4SFhUl4eLgkJibq60qF7EFBQQJAZs+e7ZXd9YdEzz+jRo1SMreK/Wlmrajan2bXimr9aWbmqvanlZmr1J9WHhNV60+zM1etP83mVqk/f/jhB+nXr58kJCRIWFiYtGrVSrp16+az+1XqT8/s2osdRUVFXsdTqT/Nzryi/rzpppvc9ldp5jk5OdKiRQsJCQmRqKgovUM9T8yrlltErf40u1ZU7E+rM1elP60+JqrUn1ZmrlJ/Wsntr/7cuHGj17+rkcLCQvnjH/8oycnJEhYWJnXr1rW9PyuTXXvOsnHjRq/9/NWf1Tlzf/dnZbNfe+21XjPXfgZt1aqVW39OmTJFcnJyTOWpiEPE4EJoREREREREREREREREBn4Vn7FARERERERERERERETVgycWiIiIiIiIiIiIiIjINJ5YICIiIiIiIiIiIiIi03higYiIiIiIiIiIiIiITOOJBSIiIiIiIiIiIiIiMo0nFoiIiIiIiIiIiIiIyDSeWCAiIiIiIiIiIiIiItNC7A6gGofD4fM2EfFjEmsCNTcQuNkDNTcQuNmZ2/8CNXug5gYCNztz+1+gZg/U3EDgZmdu/wvU7IGaGwjc7Mztf4GaPVBzA4GbPVBzA4Gbnbn9L1CzB2puILCze+I7FoiIiIiIiIiIiIiIyDSeWCAiIiIiIiIiIiIiItN4YoGIiIiIiIiIiIiIiEzjiQUiIiIiIiIiIiIiIjKNJxaIiIiIiIiIiIiIiMg0hwTax00TEREREREREREREZFt+I4FIiIiIiIiIiIiIiIyjScWiIiIiIiIiIiIiIjINJ5YICIiIiIiIiIiIiIi03higYiIiIiIiIiIiIiITOOJBSIiIiIiIiIiIiIiMo0nFoiIiIiIiIiIiIiIyDSeWCAiIiIiIiIiIiIiItN4YoGIiIiIiIiIiIiIiEzjiQUiIiIiIiIiIiIiIjKNJxaIiIiIiIiIiIiIiMg0nlggIiIiIiIiIiIiIiLTeGKBiIiIiIiIiIiIiIhM44kFIiIiIiIiIiIiIiIy7RdxYmH06NFo3Lix2zaHw4Hp06fbksesQM0NBG72QM0NBG525va/QM0eqLmBwM3O3P4XqNkDNTcQuNkDNTcQuNmZ2/8CNXug5gYCNztz+1+gZg/U3EDgZmdu/wvU7IGaGwjs7DVJ2RMLDofD1J+PPvqoxrNkZmaWm2Hs2LFVzp2bm4u6desCAPbt2+f33Fayd+zYEW+88QaOHj3qtr061fTM58yZg1atWiE8PBwAsGrVKhw/ftyvua1kdzgcPmf+3nvvVTm31exWZi4iyM/PR8eOHREdHY2kpCQAQFZWltK5S0tLkZubi7S0NISFhSEtLQ0AUFpa6vfcFy5csJQ9Ly8Pp0+fRnR0NGrXro2RI0dWS+bKZLeS+8yZMzh79iw6d+4Mp9Np6+OKlZn/6U9/wv/3//1/OH78OKKiotC2bVvMmjXLtuxWZn7w4EGcOnUKSUlJCAsLQ5MmTQCUdZLKuV0VFxejTZs2AIAdO3b4PbeVtdK/f/+A78/FixejY8eOiIiIAAC88cYb+Pbbb/2a28rMHQ7f/blixYoq57aa3erMCwoK0K1bN8TFxaFOnToAgIMHD/o9t9Ue2r9/P7KzsxEWFoZ69erh0UcfrZbMlcludebFxcXo37+/3qEAcPHiRaVzq9Sf//3vf01nZ39WT24rM3d9PNf60871YiX3tm3bDB/LX375ZaVza1ToTytrxeFgf1ZHbqv3T/anf3Or1J979+41nZ39WT25rcxctf7cu3cvhg4dirS0NERGRiIhIQE33ngjNmzY4HXc0aNHGx6vVatW1ZI7pFqOUgNWrlzp9vcVK1Zg8+bNXttbt26NV155pdpe7DOSmJjo9X0BYOPGjVi1ahX69eunb1u5ciUWLlyIL774Av3798eRI0ewf/9+BAUFYerUqWjZsqVh7mnTpqGgoMC23ADQrVs3PXdSUhLWrVuHvLw8PPXUU3puAFi0aBHq1auHmTNnwul06tur88XLmpr5okWLcNttt2H27NkYO3Ys2rdvjzFjxiA0NBR5eXmoX7++33ID5mZeVFSES5cuISoqCiKiz1w7ZtOmTauUuTLZrcw8Pj4eZ8+exYABA/Dggw8iNzcXTzzxBJYvX47x48ejS5cuSuYuLCxEXl4ehgwZgmuuuQaff/45jhw5gg8++AAzZsyoUmaruc+cOQMAqFOnDhITE3HgwAGkp6dj7969XseIjY3Fp59+itTUVEyePBkXLlzACy+8AAC4cuVKlXNbzf7Xv/4Vjz76qFt2wPsxvnXr1ujUqRM2bdoEh8OBtLS0anvyX5ncZmd+6dIljB07Fl26dMEDDzyA1NRUfPbZZ3jmmWcAACLi9+xWZt6uXTs0bdoUHTt2RHx8PI4cOYJZs2Zh2bJlePzxx5Gamqpkbtf+XLBgAY4dO1alnFXJbeX+uWHDBoSGhmLJkiVK9KfVmd9///2YNGkS7r33Xjz00EMYO3YsYmNj8dNPP/k1t5WZ5+XlefXnl19+ifnz59vSn1Zmrv0iR5cuXfDss8/i0qVLeOSRR7B69WoMGTIEgwcP9ltuKzN/99138cUXXyAjIwP9+vXDvn37sGDBgiplrUr2a6+9FgcPHkSXLl3QsGFDfPTRR/jxxx8RFhaGZ555Bg0aNABQNvNnnnkG77//Pn744QfMmTMHFy5cwJNPPomVK1di9uzZCA0NVTK3Sv05b948xMbG6rlzc3OxYcMGXL58GXPmzNFzq9ifVmauUn+anbmWXevQmuhPq9mtzLx79+7IysrCq6++qn/9yJEj0bdvX6Vzq9SfVtaKav1pZeYq9aeVmavWn3/4wx/w73//G82aNUN8fDy2b9+O77//HgBw3333oVevXgDU608ruVXqz6NHj6Jdu3Z67suXL+P9999Hbm6uW24V+9PKzFXqT7Mz17Kr1J9Hjx5Ffn4+Ro0ahdTUVBQUFGDt2rUYNGgQli5dinHjxrkdIywsDP/4xz/ctsXGxlZPcAkQEydOFCtxAcgzzzxTc4FEpHfv3lKrVi0pLCzUt+3cuVMAyPPPPy8iV3M3bdpUfvvb3xoeZ/fu3RISEiIzZswQADJ06FDbc4uIjB8/XgB45b7pppskPT3d67iBMPN58+aJ0+mUnTt3KpdbxPfMfR0TgDz55JM1ktn1+1R25sXFxRIRESFDhgxxOyYAASCTJk1SMvcXX3whAOTpp582zP3tt9/6NfelS5fk5MmTIiLy3//+VwBIr169DB8Tf//730tERIQcPXpU37Z582YBILfeemuN5baS3ddj+alTp6SgoEBErv7b2HX/NDvzoqIi2b59u9cx//KXvwgAGTlypBLZrfYnAJk7d26159VUV+7Tp09LbGys3p99+/atscxWcvu6f44aNUqioqK8tqu0zn3NfM2aNQJA1q1bp2RuXzM3MmbMGAEgjzzySI1k1lR15s2bN5drr71WSktL9W0AxOl0yqBBg2zPbTTzEydOSEhIiNdj34IFCwSADBs2rMZy+8q+fft2KSoq0v+u9UtYWJgMHz7c7euNOlT7N1q6dKmyuVXqT8/cIiLDhw8XAG65VexPKzM3Yld/mp25K8/+VGW9lDdzow4NhNwq9Wdl1oorO/vTysxV6k+zM1exPz1pM+/QoYO0bNnS7TaV+tNKbpX608iDDz4oANxyq9ifnsqbuRG7+tOI0cxdqdKfRkpKSgxn7utn0Oqi7KWQrDC6zpWR7Oxs3H///fpbbtLT0/Haa69V6nuePHkSW7duxeDBg/XL6QBlZ5mDg4O9zg6NGTMGn332mdvlX7TckydPRkZGBm644QalcoeElL2hxTO3lqlx48a4cOFCud9PpZmXlpZi+vTpcDqd6NKlC0pKSny+S0TFmbuuc+2Yrl9jd3bAe+bFxcUoLCzEpk2bDI+vvRVYtdyffvopALj9RpSrNWvW+DV3WFgYkpOTTR1j7dq1qFu3Lm688UZ9W58+fQCUvV3OlWrZn3jiCbRu3brC/VTKHRoaiu7du3v1UEZGBgAgJydH2exA+f3p+nZUVXP/6U9/QsuWLTFixAjD/VTLDZS9C61x48Y4f/58ufupln3ixIkIDQ1FRkYGSktLfb61XbXcgPs6Lyoqwtq1awEAtWrVUjp7VlYW9uzZ4/U269DQUL/3p9ncn332GUpKSnDixAm3x5Zhw4YBAPbs2eO2vz+yd+/e3fA3JdPT07F//363bcuXL4fD4UDDhg3dtteuXRtvv/22srlV6k+j3HFxcQDgllvF/rQyc5X60+zMXbM3bdq03P60MztgPPNt27ahoKAAV65cKbdDVcutUn9WZq2o0p9WZq5Sf5qduYr96UuDBg28LlujUn9aya1SfxrR1rBrbhX70xejmavUn0aMZu6aXZX+NBIcHGw4c01F/VlZyl4KqbqdPn0a3bp1g8PhwEMPPYTExET83//9H8aMGYPz589jypQplo731ltvobS0FMOHD3fbvmvXLrRo0cKrbLXLvXzzzTdub3crKCjAjh07sH//fmRmZiqXW+OZOy8vD7m5uYiJiUFSUpLXZweokN1z5vv27UNhYSHi4uIwbtw4vPHGG7h8+TIA4MiRI8rk1njO3OiYnuzO7jnziIgIJCQk4Oeff8aqVatwww036A9yERER+gv8quUuKioCAJ/XzPvqq6/8mtus7Oxs/PTTT+jcubN+2QpXJ0+e1P+/atnNCpTcp06dAgBERkbq21TO/vPPP+PKlStub+ns3bu30rkvX76MN954A9u2bTO8r6qau6SkBMeOHUNsbCzi4+Nx9913K5/9/PnzOHPmDGJiYjB16lQsWLBA/8UC1xOWquU28uGHHxo+2VYxe3JyMjIzM7FgwQLcdtttuHTpEoCyF3cmT56sZG6tPz1/6UF7LFSph06fPo309HT979nZ2bh06RLi4+O99q1Xrx527dqlZG6z7Mwt/7ssQ0LC/8/efYdHVabvA78nySSTXiCkAIaOEOrGBcRCV0BBIkVQEBZQVBR01+5XZAllrSuyNF1FYBEswA8buLALuKKiUlwQEBACIdQIKaSR8vz+yJ7j1OQMCXPe0ftzXblcZk4ON8++M/ckZ+ac+jVuq2J/VjdzVfuzupnn5OTg4sWLePXVVz2+1lV15iKCqKgoFBUV6Y9V7ec5FXP7Q38afXyq2p/u1orq/elu5ir3Z2FhoX6aYABYv3497rjjDv1+VfuzptxGmZl79+7dAH7pleqo0J/ezFyl/jQ6cxX70z77hx9+6HHmRUVFDv05atQoPP/884iIiPAqj1tX7LMQday6UyGNHTtWUlJSHG6D08dRJkyYIElJSZKTk+Ow3ciRIyU6Olr/+JNRaWlpkpSUJBUVFQ63p6amSu/evV1y//DDDwJAFi1apN83evRoCQwMlKeeekpERDZv3uxyKiSzcttnd849fvx46dixo8THx8uyZctk8ODBbj8CpNrM16xZIwAkICBAWrZsKUuWLJElS5bot2mnt1Fx5iKO61zbp+ozFxFJT0+X4OBg/d+lfU2ePFnZ3KtXrxYAUr9+fYfv17K3a9fOp7ntVXcKCu2+66+/3u1zIgApKSkxPbuR53JPH0VVbebusouI9O3bVwDIE088oUT2mnKHhIQ4PD779++vfO7g4GAZNWqUiIgcPXrU5VRIKq6VJ598Utq1ayfx8fGycuVKGTt2rP7vtD/1mmoz37lzp96VCQkJsmDBAlmxYoW+/fr1603PbfTxOXToUH29q/Lc4in3HXfcITabzaU/x48fr0RudzPfsWOHAJDOnTs7PCdu2LBBPw2FmdlFHPvlzTffdPl3uev+7t276x2qWm4RdftTo3Wic27n7Pbbmt2fIsZmrlp/ajzNvLKyUurXr6+fEkHrT1XWS3Uzb9eunURFRcm7777r0KGNGzeWsrIyJXOr3J8ao49PlfpTpPq1omp/atzNXOX+1E7XrH0NGzZMzp8/r9+van/WlFtEzf50zg3AJbdzdhE1+tObmavUn0Zmrmp/2mcPCAhwO/Mnn3xSnnjiCZf+vO666/T+rI1fxamQaiIiWL16NQYNGgQRQU5Ojv518803Iy8vDzt37jS8v4MHD2LHjh0YOXIkAgIcR1hcXIyQkBCX79E+slJcXKzftmfPHgDA008/rWxu+/s1b775Jjp16oSwsDCMGTMG69at0z+xcOLECWWyO89ce3dIZWUl/vWvf2HcuHEYN26cvv0LL7ygRG77+2vapz0Vsrtb51arFVarFZMnT8aaNWuwYMECAFVHXnNycpTMPXDgQISHh+P8+fNYs2YNjh07pn+E02KxoLi42Ke5jdLyBwYGVruNitmN8Jfcs2fPxqZNmwD8srZUz75+/Xp8+umnePnllwFUncZM5dyHDx9GWVkZnn/+ebf3q5p7zpw5SEtLQ1hYGEaOHIm3334bs2bNAgDs27dP2ez2/blu3Trcf//9uPPOOwFUffps5syZSuZ2lp+fj08++QQDBw50uF3V7IGBgbBarRg7dizef/99/SPU7777Lg4fPqxk7t/97nfo2rUr9uzZg4sXLyIzMxPr16/HpEmTAFR9Ygcwd+YXLlwAAFx77bUYO3asfrvWoe7egaa9g1S7MJ5KuY0wc94HDhzA1q1bAaDG3Kr1p5GZq9if1c387bffxoULF9y+s1ij6szT0tIQGxuLESNG6B0KVJ325oMPPlAyt+r9afTxqWJ/VrdWVO5PTzNXuT8ffvhhbNy4UX8Hd0VFhcMnhVTtz5pyG2HmvJcuXYqUlBQAqDG3Kv3pzcxV6k8jM1e1P+2zDxgwwO3M58yZg7/85S8O/Tlr1ixs27YNH3zwgeE8HtX60ISP1OYTC2fOnHE5+uT8ZX8xpZpMmzZNAMh3333ncp/Rd0QfPXpUAgMDpV69evq2zp9YMDO3fXb73BrnmR84cEAASK9evUzP7mnm77//vgAQm83m8P0ApEmTJtK0aVO/mLn9PlVf52VlZRITEyORkZEO34//HU19/PHHlcwtInLbbbeJ1WrVM2hH1MPCwqRjx44+zW2vLj6xYHZ2I8/l7t4xYnZuI++IXrVqlVgsFv3idqpk97Y/AwMDZd68eUrmzsvLE5vNJtHR0fptzp9YMDu3N59uKSoqEqDqHWoqZHeXW7svKCjI4XYA0qlTJ7FarZKdna38zN966y0BIB988IFfPD6Tk5MlNDTU4Tag6nXMiBEjTM/taeYnTpyQBg0a6BkCAwPlscce07tUxLyZnzp1SqKiogSAZGdnu/13VfeOy+PHjyuXW0Td/jx16pQ0a9ZMIiIi/K4/vZm5RoX+rG7meXl5kpCQIB07dtSzu3vHpb/NHIBMmDBBydwq96c3j0/V+rOmtaJqf9Y0c5X7U+SXfunXr5/DxbFV7s/qcouo25/O2Z1z22dXrT/tc9c0c40K/emc3T636v1pz93M3SkqKpKAgACZMGGC4X178pu4xoJ2LvrRo0d7PBLfoUMHw/t755130Lp1a6Slpbncl5SUhOzsbJfbtXPiJScnAwCmTZuGsLAw2Gw2/doK2jnRCgsLkZmZqV/kx8zcGi23J9q1ALSj1SrOXPuvuyN94eHhyM7OViK3xtPMPe1ThezOM//888+Rm5uLhIQEl23r16+Pbdu24ZFHHlEuN1B1Ua3k5GR88sknuHDhAtq2bYt69eqhqKgIrVq18um8jUpKSgLg+dMuNpsNISEhSmY3QvXcJSUluPvuu3HLLbdg0aJFDhf/Vj27s6SkJKxYsQLDhg0DoFbul156CZWVlQgPD9f7U/u0XHFxMTIzM/XneZVye6JdRNCM/jSqpv4sKyvT35WpUm5nK1asQHR0NG699VaH21Wc+ZEjR3Dy5EnUq1fP5b6rrroK27ZtUzI3UHU+5QEDBmDTpk1YuXIlWrZsicTERLz44ov6v8eM7Hl5eRgwYIB+Hmvn11lah1ZUVLh8b0FBAeLi4mC1WpXLbYSZ887NzcWgQYOwcuVKj9uq1p+1mbmZ/VnTzF966SVcunQJTZo0wXfffYfMzEy9P4GqC1VeunTJ72YeFhaG8+fPK5lb1f705vEJqNWfNc1c1f40MnNV+9PZsGHDMGnSJBw8eBCtW7dWtj9rym2ECvMGgG+//dZtbtX605k3M1ft50/7mavcn86Mzjw0NBT16tXD+fPnDe/bk9/EgYX4+HhERkaioqICffv2rdW+tm/fjsOHD2PGjBlu7+/UqRM2b96M/Px8hwvEbt++Xb8fAI4fP46CggIUFBSgadOmDvv49NNP0bRpU/1CT2bmtr+/OkeOHAHwy4ViVJx5+/btYbFYPBZefHy8Ernt73dWWlqKY8eOud2nCtmdZ37mzBkA0C9QZa+yshLl5eVK5rbn7sJxffv29Wluoxo2bIj4+Hi3F24Gqi5kBvh2rdQllXOfO3cOZ8+exbXXXov33nvP5cJrKmd3p6ysDHl5eUrmPn78OC5duoSTJ0+69OcXX3yBpk2b4rvvvlMutycFBQUAzOlPo5KTk2Gz2fSPKNsrKCiAzWZD06ZNlcttr6KiAps3b8a4ceNcTomn4sxV68/LERQUhBtuuAHAL6f6atasGQDfz7ykpASDBg3CwYMHceutt2L16tUu2zRs2BAhISH6L6vsZWdno1OnTkrmNsLM3Js2bcKKFSs8bqtaf9Z25mb1p5GZHz9+HBcuXMC6desAwKVD586di3HjxqF9+/Z+NfOioiKf/xxnNLeK/enN4xNQqz+NzFzF/vR25ir1pzvam2G0C/Sq2J9GchuhQm6Nc27V+tMdb2au4s+fWm5V+9MdozMvKChATk4O4uPjLzuj5jdxjYXAwEAMHToUq1evxt69e13uP3funOF9vfPOOwCgnxvR2bBhw1BRUYHXX3/d4fYlS5aga9eu+jv7Z86ciV69eiE+Ph5r167F2rVrkZGRAQDo3r071q5di6ioKFNza7+At8+dn5/vUhgigpkzZwIAWrRoAUDNmUdGRqJRo0YoLS3FgQMHHLbNyspCv379TM/tbub2CgsLPe7T7OyA68xbtWrlkNteTk4OOnfurGRud7Qn6IiICIwaNcqnub0xdOhQnDhxwuEA2r/+9S8AvxwkUTV7TVTNvX//fvzrX/9CUFAQPv74Y/0d6PZUzF5eXu7xnJdnz57FNddco2TuKVOmuPTn4sWLAQAdO3bE2rVr0aJFC+Vyl5SU6AcR7Gndb0Z/eqNp06aoqKjAxo0bHW4/cOAAevfuDavVqmRuTWFhISorK3HXXXe53KfizLX1UFhY6PLLkWPHjvm8P2ujsrISjz/+OADgmmuuAeDbmVdUVOCOO+7AV199hffff18/yO5OSkoKiouLkZWV5XD7+fPnMXz4cGVz18TM3Ndee63HfanWn0Znrlp/Gp35lClTsHbtWocO1foTAO644w40bdpUyZmXlJS4/eW8pn///krmBtTqT28enxpV+tPozFXrz8uZucbs/jx79qzb25ctW4bQ0FC0bdtWv02l/vQmd03Mzq29A945t2r9aXTmqvWn0Zmr2J/uspeVlbnMvLqfQUUE/fv3N5zJo1qfTMlHanONBRGR06dPS0pKioSFhcnUqVNl8eLFMmfOHBk+fLjExsYaylBeXi4JCQnSrVu3arcbPny4BAUFyWOPPSY9e/YU/O+8ilu3bq02t/M1FszMvXjxYklMTBQADrk3b94siYmJ0rZtW4mLi5OXXnpJrrvuOpdzi5mZvbqZ33bbbWKxWCQpKUnmzJkjc+bMEaDqvPknTpwwNbenmWvuvvtuCQgIcNinP8w8KSlJAEh6erosXLhQP0+c1WqVAwcOKJs7JSVFIiMjZfHixfLiiy9KmzZtBICMGTNG38aXuefNmycZGRly//33CwBp1qyZAJCMjAzJzc3Vtzt+/LiEhIRIUFCQvPbaazJ79myJjY0VAPLMM88okV3L7Zx96NChEhMTIxkZGdK1a1d92169esmyZctMz+1u5vn5+dK4cWMBIDExMbJ8+XL9C4CMHz9e359qM79w4YIEBQVJRESEvPzyy7Jo0SK9a202mxw8eFDJ3CKu/el8jQWzc7tbK0ePHpWYmBhp3bq1xMXFydy5c2XgwIH6v3PatGlKZPc08xEjRkhgYKBERkbKc889J6+88or+/Ll7927Tc3t6ThSpWi/BwcGSnJwsFRUVImJufxqdecuWLfXnwHnz5sns2bMFgFgsFr2zVJz5lClTpFWrVvo679q1q1gsFtNmPnXqVAEggwYNkuXLl0vfvn0FgP5cbW/YsGESEBAgzZs31zsUgDRo0EBKSkqUza1Sfzrnds6uUbE/jc5ctf40OnONfYe6O0e0mdk9zfzo0aNitVolMjJS5s6d69ChzZs315/bVcstolZ/Xs5aUaU/vZm5Sv3pzcxV688hQ4ZI7969Zfr06fLGG2849MvLL7/ssK1K/elNbpX60zl3RkaGxMTEuORWsT+Nzly1/jQ6c41K/eku+9VXX+2SXfsZ9P7773fpz/79++vP7bXxmzmwIFJ1IY3JkydL48aNxWq1SmJiovTp00def/11Qxk2bNggAOS1116rdrvi4mJ59NFHJTExUQICAgSAbNiwocbc7g4smJU7JCREv3CQvSNHjsjw4cMlPDxc/4V8WlqaLFq0yG9mnpSUJH379pXw8HCJjIwUAPLggw+antvTzDXaCxD7ffrDzEePHi0xMTHStm1bCQ0NlejoaAEgkyZNUjp3WlqaBAUFic1mk9jYWBk8eLCp805JSdGLy/nr6NGjDtvedtttYrPZJCwsTGJiYuSuu+7yi+w333yzx+169OihZG77FxTuvjp27OiwT5Wyl5aWSps2bcRqtUpUVJRYrVb9+6ZOnapsbhFjBxZUy33hwgUZPXq0REZGisVikZCQEElNTdV/8FL98Tl27Fhp2LChpKenS1RUlISGhgoAmThxotK5RapeeAOQP/7xj/pt/jDzMWPGSFxcnHTq1EkiIiL0iz3efffdSudesmSJxMbGisVikcjISOnTp4/8+9//Nm3mPXr0qPZ52t7YsWMlOTlZbrrpJr1DAcif/vQnpXOr1J9Gc6vYn0azq9af3qwVEWO/GFEt+4ULF6RZs2YSFBQkYWFheocCkP/7v/9TNreIWv3p7VpRqT+9ya5Sf3qTW7X+XLlypfTt21cSEhIkKChIQkJCBICsW7fOZVuV+tOb3Cr1p3Pu2NhYadSokcs6UbE/jc5ctf40OnONSv3pLnvfvn1dZq79DNqiRQuH/pw9e7ZcunTJUJ6aWETcnHyOiIiIiIiIiIiIiIjIjd/ENRaIiIiIiIiIiIiIiKhu8MACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhvHAAhERERERERERERERGRZkdgDVWCwWj/eJiA+TeMdfcwP+m91fcwP+m525fc9fs/trbsB/s/9acjcEUAAgH2rnBn49M7encm7Af7P/ZLGgOYCfANzRoAGOlJUh/MIFbAHQXOHc/jpvwH+z+2tuwH+zM7fv+Wt2f80N+G92f80N+G925vY9f83ur7kB/87ujJ9YICIiIgLQCMBWABsARJmchagu9UTVQYXmAP5ZVoYHf/e7qoMKZoYiIiIiIiK/xgMLRERE9JvVyO6/W1D1i9YGACLNCkR0BZzALwcX4i5cwIx//Uv/BAMREREREdHl4IEFIiIiumL+/ve/mx2hWlsAXItfDir8hKpfwGablojoyjgBYIzTbc5/JiIiIiIiMsoi/nbypivMX89z5a+5Af/N7q+5Af/Nzty+56/Z/TU34L/ZPeVu164d9uzZ4+M0XrDLrR1UOPG/P6s8b+DXt1YAtXMD/pvdYrE4fCpH8xN4jYUrxV+z+2tuwH+zM7fv+Wt2f80N+G92f81D6TnNAAEAAElEQVQN+G925vY9f83ur7kB/87ujJ9YICIioitm7969ZkcwbAx+OahA9Gtif1DhJwDd8cs1F4iIiIiIiC4HP7FAREREv1327xZp1gzYsgVo3Ni0OERXRPPmwJEjjms8Kwvo2RP4iVdaICIiIiIi7/HAAhERERERERERERERGcZTIRERERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhvHAAhERERERERERERERGcYDC0REREREREREREREZNiv4sDCuHHj0KRJE4fbLBYLpk+fbkoeo/w1N+C/2f01N+C/2Znb9/w1u7/mBvw3u7/mBvw3O3P7nr9m99fcgP9mZ27f89fs/pob8N/szO17/prdX3MD/puduX3PX7P7a27Av7NfScoeWLBYLIa+tmzZcsWzZGZmVpvhnnvuqVXuhQsXolOnTggNDQUALF26FN9//71Pc//www+Gs1ssFixduhTHjh1zuA0Ali1bVuvc3mb3duZFRUXo1q0bYmJiUK9ePQDAwYMHfZ7bm5lv2bIF+/fvR3Z2NkJCQtCwYUP88Y9/rJPMl5Pd25mXlpbi+uuvR1hYGBITEwEAly5dUjr3yZMn8fPPP6Ndu3YIDAx0KRBf5vYm+9SpU/HPf/4TWVlZiIyMROfOnbFw4ULTsnsz8//+9784deoU4uPjYbPZ0LJlSwBAYWGhz3N7m12Tm5uLBg0a6M+JdeVKzXzDhg1un8v/8Y9/+Dy3t9krKyuRl5eHq6++GjabDQkJCQCA/Px8n2c3mnvVqlUe+/PPf/6zyzxUyb1lyxaICAoKCtCpUydERETo887Kyqp1Zm9ze5N906ZN2L17t96fzZo1w8yZM+sk8+Vk9/Z5RZX+3LJli+HsL774IrZt24aTJ09ekf70NrvR3Bs2bMCBAwdw5swZJCUl6R0KAJWVlcrmVq0/vVkr7M+6ye3tzNmfvsutWn96s1bYn3WT25vs7E/f5latP73NrmF/Xn5ub7Or1J+anTt3YvDgwYiLi0NYWBjatWuH1157rVb79FZQrfdwhSxfvtzhz8uWLcPGjRtdbm/Tpg3eeOONOnvCcic+Pt7l7wWADRs2YMWKFbjpppv02/70pz/hn//8J1q0aIHY2Fhs27YNP/74IwDgD3/4A3r37u2Qe/z48ZgyZQruvvtuPPjgg7jnnnsQHR2Ns2fP+jT3sWPH0L59ez33pUuX8PHHHyM3N9chNwDk5eUhPDwcIgKr1QoA+O677zB37lw0b9681rm9ze7NzDt16oSlS5eiS5cu+Mtf/oKSkhI88sgjWLlyJYYNG4bbb7/dZ7m9mfkHH3yAb775Bunp6bjpppuwb98+zJs3r1ZZa5Pdfrvz58/jkUceQWVlJRo2bIi//OUv+n1t2rTB5MmTsWrVKhQVFeGVV17BiRMnMGvWLLz33nuYPXu2srkTExNRVlaG6OhoJCcn1zpnbXLbZz9//jwee+wxlJeXo7Ky0mEfWVlZePrpp9G7d2889NBDiIuLw2effYYHHnjAtOzezDwlJQVpaWlITU1FZGQk9u/fj5dffhlvvvkmpk+fjvDwcJ/lts9e3cy17FoPPfbYYygqKqpVztpm92bmrVq1QlBQkMPtY8aMwXXXXefz3PbZa5p5ixYtkJ2djdLSUvTv3x8dOnTAhQsX8Oijj6KkpMTn2Y3OvEuXLliyZIlDfwJVMwfgMg9Vcrdp0waxsbE4f/48Bg4ciAceeAC5ubl44oknsGTJEkyaNAldunTxWW777DWtlXnz5uH777/HuHHj0LVrV3z99dd49tlna5W1NtmffvppzJ49GzfddBOaNWuGL774Anv37sV9992HDh06IDIyEoB6/anRcgPQsy9YsEDPDQAfffQRsrKykJaWhhMnTtQ6Z22zG525zWbD9u3b0bt3b/Tv3x9RUVH47LPPsHv3bqxbtw4zZsxQMreK/QkYWyuq9ac3M1etPwFjM1etP43OXLX+9GatqNafgLG1olp/Ll++HHv27MHLL7+MJk2aIDAwEAcPHsStt96KyspKjBo1CoCa/fn444/rubt27Ypdu3Zh//79GDhwoJ4bUK8/jc5ctf70Zq2o1p9G14pq/enNzFXrT6MzV60/AeCf//wnBg0ahM6dO+PZZ59FREQEfvrpJ4fnj8vpCK+Jn5g8ebJ4ExeAPPfcc1cukIj06dNHoqKipLi42OM2Wu6OHTtK69atHe579913BYCsWbNGv02V3CIiDzzwgABwye3OhAkTBIA88sgjdRXTrdrOvGXLlvL73/9eKisr9dsAiNVqlcGDB5uaW8T9zE+ePClBQUEyZswYh23nzZsnAGTkyJFXJLOmpux33HGHNGzYUABIamqqy/0DBgyQpKQkycvL028DIADks88+UzZ3dna2XLp0SUREbrnlFklJSVHi8XnHHXdI7969JTk52eU58dy5c7J3716X7/nDH/4gAOShhx66Ipk1tZ25O9paWblyZV1GdVCbmdvbs2ePBAUFyYwZM/TcKqyX6mbeo0cPl9tVyV3dzJ9//nmxWq2yfft2h9tVyX456zw4OLjGjqiN2uQuKyuT0NBQGTZsmEtuADJlyhRTc3taK998840AkGeffdbh9j/96U8CQO67774rllvEffbNmzcLAHn//fdFpPrXtyr1p3Pu6rK7608tuxmPT6Mz99Sh2swPHTqkZG5PzOpPb9aKRpX+9GbmKvWnNzNXrT/rYp2b0Z9Gc6vWn0bXior9mZeXJwkJCZKeni4VFRV+05/OuUX8pz+Nzly1/vRmrbhjVn96s1Y0qvSnNzNXqT+9mblq/ekue233ebmUPRWSN9yd58qd7OxsjB8/HgkJCQgJCUFqaireeuuty/o7T506hc2bN+P222+HzWarcfvGjRsjNzfX4bbJkycjODgY6enpqKys9PhxK7Nyax9Jcs4NOM68tLQUq1evBgBERUUpkR1wP/OsrCzs3bvX5WNiwcHB+qmozMztbuZfffUVysvLcfLkSYd1PnLkSADA3r17Hfbhy+yff/45PvjgA9xwww1uvz8/Px8bNmxAYWGhy9qwWq147733lMwNVL0TSfsoZHXMyP3qq6+6/f769esjNTXV5TkxPT0dAHDu3DnTs1c38+qey+0fEyrN3D7773//e6Snp1f7b1Rt5gcOHMDBgwdRXl6OixcvKpXb08wrKysxd+5cNGzYECNGjEB5eXm179JRbebO6/zUqVMAqt7BY79PlXKXlZWhuLgYn332mdv7zerPmtbKf/7zHwDAf//7X+X6EwAKCgo8fuJW1f7UcpeXl3vcR3JyMu655x4lX5tXN/P69evjxRdf9Jh7//79SuYG1OxPLXd1a0XLrlp/atmrm7mK/anl9jRzlftTy+7NOlehP2vKrWp/ark9rRUV+/Odd97BmTNnMGvWLAQEBKCsrMzt96vWn865CwsLISJu96FafxqduWr9aTQ3oFZ/erNWtOyq9Kc3M1epP43OXMX+dJfd6Jl8vP3dak2UPRVSXTtz5gy6desGi8WCBx98EPHx8Vi/fj0mTJiA/Px8PPzww17tb9WqVaisrMRdd93l9v7CwkIUFxcjLy8PALB+/Xrccccd+v35+fnIyclBZGQknn76acybN09/UP3www9K5N69ezcAoE+fPtXu89NPP3V78EG1mQNAYmIiMjMzMW/ePAwaNEj/yFJpaSmmTp1qem53My8tLQUABAU5PlzDwsIA/PKi2tfZKyoq8NBDD2HixIku2TR79uyBiCAkJMTlvsTEROzatUvJ3EaZlbt9+/Ze7ff06dMAflkzZmY3MvOcnByUl5fj0KFDAKoOuPXs2dPU3DXNPDMzEyUlJXjhhReQmZnpdhtVZ15WVobw8HBcunRJP09kRUWF6bk9zXzfvn04efIkOnfujEOHDunZ3W2v6syd9wkAHTp0UDZ3aGgo6tevj59//hkrVqzADTfcoPd+aGgo7r33XlNze1orqvYnUHWqxosXL+pvKPjuu+9wzTXX6Per2J/2uQMDA/Xni8ul2sxrUr9+feVzq9Kf9rlrWiuq9ad99ppmrlJ/2uf2NHNV+9M+uzePT7P700huFfvTPrentaJif27atAlRUVHIzs7GkCFD9Gsk3n///fjrX/+q/3JMtf50l1uba0lJyWX9Uk+1mdfE1/15OblV6E9v14pK/entzFXpT6MzV7E/3WUPDw/HmDFjanx81tQRXqv1Zx58pLqP0owdO1b/mJgGTh9HmTBhgiQlJUlOTo7DdiNHjpTo6GgpKiryKk9aWpokJSV5/MjJpEmT9I8iAZBhw4bJ+fPn9ft37twpACQgIEASEhJkwYIFsmLFCn379evXK5EbgENujf3Mhw4dKiEhIcrPXKTqlAk2m83l3zh+/HhlcjvPfMeOHQJAOnfu7LDON2zYoJ/GyYzsf/vb3yQ6OlrOnj2rPz6dP9L2/vvvCwBJTEx0uB2AtG3bVr9dtdwijmvc06mQzMotItWelsc+e2lpqbRt29bl48yqzrxRo0Yujwf7j4+rOPOioiIJDw+X6OhoEfnlY+aqrJfqZt6iRQuJjo6W1atXy7Jly2Tw4MH649Ps3CLuZ75mzRoBICEhIRIUFCRLliyRJUuWSMuWLV0+nq/izJ1fs6SlpQkAmTZtmtK509PTJTg42OXxOXnyZNNzi7hfK6tXrxYAcv311zvMfNGiRQJA4uPjfZ5927ZtMnToUHnzzTdl3bp10q1bNwEgNptNdu7cqW+nWn86554zZ47+2s8+t0Zb59WdykG1mdvn1pSWlgoAiYmJkbKyMqVzq9Kf3qwV1frTm5mr1J9GZ65if9bm8Wlmf3qTW6X+NLpWVOzPDh06SFhYmISFhclDDz0k/fv312dpf2pg1frTOffq1aulffv2Lrk1KvWn0Znb59aY2Z/e5lalP71ZK6r1pzczV6k/jc5cxf50l/2hhx7y+NxiZJ+X6zdxYKGyslJiYmLk3nvvlXPnzjl8LVmyRADIF198YTjLjz/+KED11xPYv3+/bNy4Ufr06SMAJD09XU6fPq3f//nnn+sPtK+//tohd2hoqFx33XWm5l66dKn+i1T73Bpt5nl5eWKz2SQ9PV35mYuI3HnnnRIZGSljx46V999/X9566y0BIOHh4XLo0CFlZ961a1cJCgqSevXqydGjR+XTTz/Vt7VYLCLi25nn5ORIXFycvPTSSyIiHn8ZtWzZMgEgSUlJDrcDkA4dOkh0dLSSuUVqPrBgZm4R4wcW7rnnHpcXGarPfOPGjfLRRx/p54rUrn+i6synTZsmoaGhctVVV4mI+xd2qs/cnpb9q6++UnLm2vNKQECANGrUSL/92LFjAkDat28vIv4xc22f/rBWRowYIeHh4TJ58mRZs2aNLFiwQABIvXr15Ny5c0quleLiYklJSRGbzSbx8fGSmZkp7777rtSrV08ASGxsrIiY85pFo808NDRUbr75Zv121frTndGjRwsAh9yamn4xouLM7XNrtA698847/SK3Cv3pjqe1olp/OvNmrYiY15/uuJu5iv3pzOjMze5Pb3Kr1J/uuFsrKvZns2bNHH6Bp81ce5PewYMHRUS9/nTObZ/dPrdGpf40OnP73Boz+/NycqvQn96sFdX6szZrRcS8/jQ6cxX70112EXE7c6P7vFy/iQMLZ86c0ReGpy/7CyjXZNq0aQJAvvvuO8O5+/Xr53DR4G+//VYASFBQkEvuTp06idVqlezsbNNy22d3vtixyC8z134x/8EHHyg/c5GqXzyEhoY6bA9UvbtkxIgRpua2z+6c+8SJE9KgQQM9Q2BgoDz22GMCVB01FfHtzO+77z5p0aKFlJaWOuS+nE8sqJhbpOYDC2bmFjF2YOGFF14QAJKRkaFM9sv9JfdHH32k5MyPHj2qHwzWsrt7YeePM8/IyFBy5vbPK+6yx8TEiIh/zFzbp+prpaysTGJiYiQyMtLhdqDqBfbjjz+u5FoREdm7d69ER0frGUJCQmTu3LkCQBISEkREjdcsI0eOlODgYCkvLxcR9fqzuuz2uTU1/WJExZnb5xYRvUP9LbfGrP6sLrt9bhX701Nub2fu6/6sLrun5xVV+tNT7ppmbnZ/Gs2tWn9Wl9153qr1Z2pqqgCQrVu3OuTeunWrAJClS5eKiHr96ZzbPrt9bo1K/Wl05va5Rczvz8vNrTGrP42uFRX7s65m7uv+NDpzFfvTXXYRcTtzo/u8XL+JayxoF7AYPXo0xo4d63Yb+3Mz1uSdd95B69atkZaWZvh7hg0bhkmTJuHgwYNo3bo1kpOTAQABAa7Xzw4PD0dZWZl+zQUzcwPAt99+q+d2tmLFCkRHR+PWW291uF3FmR85cgQnT55EvXr1XLa96qqrsG3bNiVyA64zb9iwIQYMGIBNmzZh5cqVaNmyJRITE/Hiiy/q/x5fZT906BBef/11vPrqqzh58iSAqmuGAFXnysvMzERUVBTi4uKQlJQEwPF8eZqCggIkJycrmdsIM3MDv8zUU+6LFy/iiSeewH333Yf/+7//w7PPPqtE9suZeUREBFasWKGfs1almU+bNg0NGzbUr9+SmZmpX9MCqLroV2Vlpd/NHADOnz+v5DrX+tNms7m9uFZxcTEA/1jn2j5//PFH/TYVc3/++efIzc11ex7m+vXrY9u2bXjkkUdMyw14fk5MTU3FkCFDsHHjRrz77rto27YtQkNDMXXqVJ/3Z3UaN26MS5cu6RebVKk/a2Kf2ygVsjvP3N7bb7+td+iiRYv8JrczX/dnTexzq9af1fFm5oBv+7Mm9rlV68/q1DRzM/vTm9wq9WdNnOetWn8mJyfjhx9+cJllgwYNAAAXLlwAAOX601NujZbbKBWyO8/cngr9eTm5nZnRn0bXior9WRczB3zfn0ZnrmJ/Xu7ML7cjqvObOLAQHx+PyMhIVFRUoG/fvrXa1/bt23H48GHMmDHDq+/TFpp2YeHk5GTYbDa3V0svKCiAzWZD06ZNTc+t0XLbq6iowObNmzFu3DiXiyOpOPMzZ84AgMervJeXlyuRW+Nu5kFBQbjhhhsAVF1ABgCaNWsGwHczz87ORmVlJaZMmYIpU6Y43Hfw4EE0bdoUU6dOxauvvop27drBYrHoFwCzd/r0afTr10/J3EaokBuA29zHjx/Hzz//jKFDh2L+/PlKZvdm5uXl5cjLy1MiN+A48+PHj+Pw4cM4fPiwfp+9uXPnYvr06Upk93adx8fHK5EbcJx5+/btYbVaUVRUhNDQUJdtw8PD9fxmZ69u5vb7nDZtmn67irlV6s/LeU4EAKvViuuvvx4A8OmnnwLwfX9W58iRI7DZbIiIiAAApfqzJva5jVIhu/PMNUVFRZg4cSJuv/12zJ8/3+EXIyrndsfX/VkT+9yq9Wd1vJk54Nv+rIl9btX6szrVzdzs/vQmt0r9WRNP81alP9PS0rBx40ZkZ2c7vOFRe5NBfHw8APX601NujZbbKBWyO89co0p/epvbHTP60+haUbE/62Lm2nYq5LbPA6jZn5cz89r+jtIT17fL/woFBgZi6NChWL16Nfbu3ety/7lz5wzv65133gEA3HnnnW7vP3v2rNvbly1bhtDQULRt21a/rWnTpqioqMDGjRsdtj1w4AB69+4Nq9Vqam7taJtzbk1hYaHHK4mrOPMWLVrouZ1f3B07dgydO3c2PXdNM7ff7vHHHwcA/Si6r7K3a9cOa9eudfgaMGAAgKpPfqxduxYTJkwAAERHRyMpKQmFhYUoKChw2E9ZWRmGDx+uZG4jzMy9du1a/d24zrk///xzbN26FTabDStWrHD7qSgVZ15YWIjy8nK3f0dJSQmuueYaJWc+c+ZMrF27Fr169UJ8fDzWrl2LjIwMfV933HEHwsPDlZx5fn6+y7u57J8bb775ZiVnHhkZiYEDB+LcuXMOB+f3798P4JcfdlWcuZF9qpi7VatWAKoep85ycnJ82p/ePic6Ky4u1j/B1a5dOwC+fc3iaV8ffvghbrrpJv05W6X+9LSvnJwcAHDIbZTZ2QHXmQNVvwQ8d+4cbrzxRrcdqmJulfrT077crRXV+rO6fTnPXKX+9LQvdzNXrT+r25e7x2dN+1Qxt0r96WlfRp/Lze7PESNGAADefPNNh9v//ve/IygoCD179gSgXn96yg3AIbdRKmR3njmgVn8aza1afxpdKyr2p9GZq9afRmeuYn968/g0us/LVmcnVbrCanONBRGR06dPS0pKioSFhcnUqVNl8eLFMmfOHBk+fLh+8aGalJeXS0JCgnTr1s3jNkOGDJHevXvL9OnT5Y033pCuXbvq59J6+eWXHbYdMWKEBAYGSmRkpDz33HPyyiuvCFB13YXdu3ebmjsjI0NiYmLc5hapmnlwcLAkJyfrVxL3h5lrV23v1auXzJs3T2bPni1A1QWQtXOTqTjzKVOmSKtWrSQuLk7mzp0rXbt2FYvFYtrMnVV3PvFbb71VAEjnzp1l4cKF8swzzwgAadasmdK5Bw8eLDExMZKRkSGtW7fW/7/p1auXfPjhh6bmFnF/PvHMzEyJjo6WwMBAiYuLk+XLl+tfgOOFfVSb+a5duyQkJEQiIyPltddek7/97W8ybtw4ASDR0dGSk5Njam4R4xfMdneOSzOze5r55s2bxWazSVRUlMyfP19eeuklue666wSA/O53vzM9t4jnmf/www8SFBQkgYGBMmfOHJkzZ44kJSUJ4HghKtVmLvLLWrHfp+prRUT0+aanp8vChQv183NarVY5cOCAqblFPK+V4cOHS5s2baRevXry4osvSps2bSQkJMS0mffq1UsGDhwoM2fOlNdff106duyoP8/t27fPYVuV+tM598MPPyxBQUECwCX3999/L507d5aYmBi9P7Vr/YwcOdL07J5mnpmZKVarVSwWi8yfP9+hP9PT0+X7779XMrdq/enNWhFRqz+Nzly1/vRm5qr1pzfPiSr1pze5VepPb9aKav0pIjJ+/HgBICNGjJAbb7xRf7546qmnHLZTqT+dc8+fP1+aN2/uNrdq/emc3dPMVetPo7lV60/n3NWtFRG1+tM5u6eZq9afzrmrm7lq/eku+/Dhwz2ul8v9GcuI38yBBZGqC2lMnjxZGjduLFarVRITE6VPnz7y+uuvG8qwYcMGASCvvfaax21Wrlwpffv2lYSEBAkKCtLLd926dW5zN2zYUNLT0yUqKkpCQ0MFgEycONH03LGxsdKoUSOPMx8yZIgAkD/+8Y/6bf4w8zFjxkhcXJx06tRJIiIiJCIiQgDI3XffbXru6ma+ZMkSiY2NFYvFIpGRkdKnTx/597//bdrMndX0S7TExETp3r272Gw2iY+PFwDy5JNPKp1bKzh3X2PHjjU1t4j7X6LZv6Bw99WjRw+H7VWa+blz56RVq1YSFBQk4eHhEhwcrB8IfOyxx0zPLVL7AwtmZfc08yNHjkhKSooEBgaKzWaTsLAwSUtLEwAybdo003OLVD/zW2+9VWw2m4SHh0tkZKTcdtttys9cpGqtNGjQwGGf/pB79OjREhMTI23btpXQ0FD9go6TJk0yPbeI57Xy/PPPS1RUlACQ2NhYGTx4sOzatcu0mc+dO1e6dOkicXFxEhQUJGFhYQJADh065LKtSv3pnDspKUlatWrl8TWLpx7q2LGj6dk9zbymDrVfLyrlVq0/vVkrImr1p9GZq9af3s5cpf709jlRlf70JrdK/enNWlGtP0VELl26JNOnT5eUlBQJCAgQAPLXv/7VZTuV+tM5t9Vq1deAM9X60zm7p5mr1p9Gc6vWn865q1srImr1p3N2TzNXrT+dc9c0c5X60132Fi1auH1O9Gafl8Mi4uaEf0RERERERERERERERG78Jq6xQEREREREREREREREdYMHFoiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsN4YIGIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLDeGDBicVi8filMn/NDfhvdn/NDfhvdub2PX/N7q+5Af/N7q+5YbHgJ4sF3f/3X+3PjVXPDf+dub/mBvw3O3P7nr9m99fcgP9mZ27f89fs/pob8N/s/pob8N/szO17/pq98f8yNrY4/hzXSPHcANz+7OkPM3cnyOwARERERGY5AqA5gC//9+efAPQEcMKsQERERERERFStLQDGAFiOqp/ntJ/jss2LZNiv6WdPfmKBiIiIfrMmhoQ4/HkM/PuFHRERERER0a+d9uYw+4MK/vZz3K/hZ08eWCAiIqLfrDdKSx3+vBxAI3OiEBERERERkZf89Rf0v4afPXlggYiIiH6ztHe4dP/ff5uj6mO1/v4Cj4iIiIiI6LfA335B/2v62ZMHFoiIiOg3S/vY7Ff/+6/9Czyc8Mf3vRAREREREf26+fObw9z97NnQxDy1YRERMTsEERERkSmysoDGjR3/3LMn0KABsGEDEB1tWjQiIiIiIiJyQ/s5Tvv57cgRoFkzYOtWoJGfHGL4FfzsyQMLRERERERERERERERkGE+FREREREREREREREREhvHAAhERERERERERERERGcYDC0REREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYb+KAwvjxo1DkyZNHG6zWCyYPn26KXmM8tfcgP9m99fcgP9m99fcgP9mZ27f89fs/pob8N/szO17/prdX3MD/puduX3PX7P7a27Af7Mzt+/5a3Z/zQ34b3bm9j1/ze6vuQH/zn4lKXtgwWKxGPrasmXLFc+SmZlZbYZ77rnnsnKLCAoKCtCpUydEREQgISEBAJCVleXz3N5k37RpE3bv3o3s7GyEhISgWbNmmDlzZp1kvpzs3q6V0tJSXH/99QgLC0NiYiIA4NKlSz7PPW7cOMPZX3zxRWzbtg0nT55EYGCgy5OZr7Mbzb1hwwYcOHAAZ86cQVJSEiIjI9G5c2cAQGVlpc9zezPziRMn4pNPPkFWVhZsNhtatmyJhx9+uE4yX072y31OzM3NRYMGDQAA+/btUzr3hg0bcOzYMYfbAeAf//iHz3N7s1a2bNmCyspK5OXl4eqrr4bNZtOfz/Pz832e3WjuVatWYenSpW5n/uc//9mlI650bm9m/u9//xs//vgjTp48qffngAEDap33crN7u1Zyc3PRrFkzvUMBc54TvX1eUaU/vcnO/qyb3N5kZ3/6PrdK/eltdvZn7XN7k5396fvcAPuzLrIbzc3+rLvs3q5zDfvz8nJ7m539Wfvc3mRXrT8BYMeOHejfvz+ioqIQGRmJm266Cbt373bZb1lZGf785z879OfMmTNRXl5eJ7mD6mQvV8Dy5csd/rxs2TJs3LjR5fY2bdrgjTfeqLOScCc+Pt7l7wWADRs2YMWKFbjpppv025YvX449e/bg5ZdfRpMmTRAYGIiDBw/i1ltvRWVlJUaNGqXnjo2Nxfnz5zFw4EA88MADyM3NxRNPPIElS5Zg0qRJ6NKli89yA8Djjz+u5+7atSt27dqF/fv3Y+DAgXpuAJg3bx6+//57jBs3Dl27dsXXX3+NZ599tlZZa5N92rRpOHv2rP7nL774Anv37kVwcDDq16+P559/HkDVzCdPnoxVq1ahqKgIr7zyCk6cOIFZs2bhvffew+zZs32ae9KkSQgNDXXYTsuenJys5waAjz76CFlZWUhLS8OJEydqnbO22Y3O3GazYfv27ejdu7f+hPfZZ59h9+7dWLduHWbMmOHT3N7MfOXKlRgyZAhat26N2NhY7N+/H2+88QaAuvtB4Eqtc/vnxGnTpqGoqKhO8l7p3K1atUJQUBD+8pe/6NuPGTMG1113nc9ze7NWWrRogezsbJSWlqJ///7o0KEDLly4gEcffRQlJSU+z2505l26dMGSJUsgIrBarfr2Y8aMAQCXjrjSub2Z+XvvvYevv/4ao0aNQs+ePZGbm4vFixcDALKzs2ud29vs3qzz4uJi5OXlYdiwYbjmmmvw9ddf4+jRo/jkk098/pz46quv4umnn0ZoaCj69OmDPXv2YP/+/QCAzp07449//KOeW6X+zMrKQlhYmJ47PDwcn332GU6ePOmQG1CvP43OXLX+9GbmqvWnN+tcpf70JrdK/enNWlGtP43OXLX+9GbmqvWnN+tcpf7MyMjAjBkzEBcXh969e+O7777DoUOHYLPZMGPGDCQlJem5VerPnTt3wmq16rlFBP/v//0/lJSU4IUXXtBzA+r1p9GZq9af3sxctf70Zp2r1J/e5FapP71ZK6r1p9GZq9af3sxctf7cuXMnrr/+ejRu3BjPPfccKisrsWDBAvTo0QPffPMNWrdurW87evRovP/++xg/frzen88++yyOHz+O119/vfbBxU9MnjxZvIkLQJ577rkrF0hE+vTpI1FRUVJcXKzflpeXJwkJCZKeni4VFRUec5eVlUloaKgMGzbMJTcAmTJliqm5RdzP/JtvvhEA8uyzzzrc/qc//UkAyH333XfFcnvK7kzLDUBmzZrlcN+AAQMkKSlJ8vLy9Nu0bT/77DNTc4uI3H777W5zZ2dny6VLl0RE5JZbbpGUlBQRMW+dO/M083PnzsnevXtdtte2PXTo0BXJLFL7mbvzwQcfCAAZOnRoXcV0q7brXLNnzx4JCgqSGTNmCAAZPnz4lYosIrXP3aNHD0lNTXW4TZU1LuJ5rTz//PNitVpl+/btDrerkt3IWrEHQIKDg2ucR23UZuae+vPIkSMCQLp06XJFMmtqM3NPHapt+/333/s096xZswSA/jyt5b777rsFgJw/f17fVqX+dM5tn905t2r9aXTmqvWnNzN3x8z+9Gada1ToT29yq9Sf3qwV1frzctaKPbP60+jMVexPozNXrT8HDhwosbGxkpOT45A7IiJCbr/9dofvV6k/nXOLiIwbN04AuORWrT+Nzly1/vRm5u6Y2Z/erHONCv3pTW6V+tObtaJaf17OWrFnVn8anbmK/eku+8mTJ11mXt3vcC0WS530p7KnQvKGu/NcuZOdnY3x48cjISEBISEhSE1NxVtvvXVZf+epU6ewefNm3H777bDZbPrt77zzDs6cOYNZs2YhICAAZWVlbr+/rKwMxcXF+Oyzz9zeb/+uTTNyFxYWQkRcvv8///kPAOC///2vw8xHjhwJANi7d6/D9r7I7onFYsGdd96p/zk/Px8bNmxAYWEhoqKiHLa1Wq147733TM998OBBAHDIDQDJycm45557lFnnnjjPvH79+njxxRc95tbekWRmbk8zB1yfW7T/7fwuAJVmbp976tSpSE9Pxw033OD2e1XLfeDAARw8eBDl5eW4ePGix+9Vaa1UVlZi7ty5aNiwIUaMGIHy8vJq36Gj2syd1/ipU6cAVL2Dx36fKs1c68+9e/c6ZNc+cm3/7hczswOuM9c69M0333S7/bvvvuvT3NpHpbWPTmuSkpIQEBCA4OBgfTuV+tNTbgAOuQH1+tPozFXrT29mDqjVn0Znbp9bhf70JrdK/Wl0rajYn5ezVuz3CZjTn0ZnrmJ/Gp25av35n//8B3379kW9evUctu/Rowc+/vhj/XGoWn+6yx0eHg4ADrkB9frT6MxV609vZg6o1Z9GZ26fW4X+9Ca3Sv1pdK2o2J+Xs1bs9wmY059GZ65if7rLnpSU5DJzrT+139lqRo4cCRFx6M/LpeypkOramTNn0K1bN1gsFjz44IOIj4/H+vXrMWHCBOTn53t97rpVq1ahsrISd911l8PtmzZtQlRUFLKzszFkyBD9lyL3338//vrXv+oLITQ0FPXr18fPP/+MFStW4IYbbkBubq5+37333mt67qCgquVRUlKi5y4tLQUA/T5NWFgYgF+eFHyZ3Zn2Ebzu3bs7POj37NkDEUFISIjL9yQmJmLXrl2m5i4rK8OhQ4cAwNALOHdUm3lN6tevb2puIzOvrKzE6dOncejQITz55JMu26o686KiInz55ZfYv38/MjMzXe5XNXdZWRnCw8Nx6dIl/YfMiooK03N7Wiv79u3TTzVw6NAhPXv79u1d9qHqzJ33CQAdOnQwPbenmYeGhqJr167YsWMHYmJicPz4ceTm5iIjIwMAkJaWZnp2TzPXOlQ7l6izHTt2+DR3z5498fzzz2PChAn485//rL8AXbhwIaZMmaK/sFatP51z16tXT18r9rm9odrMa+Lr/rycmavSn97OXJX+9Da3Kv1pdK2o2J+1eXya2Z9GZ65ifxqduWr9WVpa6nL6RqDqZ+JLly5h79696Natm3L96Sk3AIfc3jA7u/PMa+Lr/rycmavSn97OXJX+9Da3Kv1pdK2o2J+1eXya2Z9GZ65ifxqdudafzttqv8PV+rNWav2ZBx+p7lRIY8eO1T+ap4HTR4AmTJggSUlJDh8TEREZOXKkREdHS1FRkVd50tLSJCkpST9tkKZDhw4SFhYmYWFh8tBDD0n//v31j92NHDnSYdv09HQJDg7W79e+Jk+ebHru1atXS/v27V1yr169WgDI9ddf7zDzRYsWCQCJj4/3eXZnt9xyiwCQBQsWONz+/vvvCwBJTEx0uB2AtG3bVr/drNwfffSRvgbc0dZ5dR9FVW3m9rk1paWlAkBiYmKkrKzM1Nw1zXzEiBEOj81GjRr5xcxHjx4tgYGB8tRTT4mIyObNm10+iqpi7hYtWkh0dLSsXr1ali1bJoMHD9Yfn2bn9rRW1qxZIwAkJCREgoKCZMmSJbJkyRJp2bKlAI6nh1Nx5s6Pz7S0NAEg06ZNMz13dY/PQ4cOSVxcnMPjs1mzZso/PrUOrV+/vsPt2r+hXbt2Ps+dkZEhoaGhDrN85plnHLZRsT/d5faX/jQyc/vcGrP705uZq9afRmeuWn8aza1afxpZK6r25+U+Ps3uT6OPTxX708jMVevP9u3bS6tWraS8vFxEfvldxVVXXSUA5IMPPhAR9frTObeIyH333afPUcutUak/jc7cPrfGzP70duYq9ac3M1epP73JrVJ/Gl0rKvZnbR6fZvanN49P1frTXfbS0lKXmWv9uXz5cofv136Hq/VnbfwqToVUExHB6tWrMWjQIIgIcnJy9K+bb74ZeXl52Llzp+H9HTx4EDt27MDIkSMREOA4wosXL6KoqAh33303XnvtNTRv3hxA1UUpV61apb97BKj6uIzVasXkyZOxZs0aLFiwAEDVEamcnBxTc99+++248cYb9Txa7oEDByIlJQXfffcdioqKcOzYMbz33nt45plnAEC/qrgvs7vbFgBGjBjhcHtxcTEA9+90CQoKQnFxsam533nnnRq3qY6KM3fnwQcfBFC1loKCgpSeeUhICBISEvDRRx9hxowZ+jtcNKrOfM+ePQCAp59+2u33qpr7uuuuQ0xMDG6//XaMGTMG69atA1D1rsavv/5aybVi//HIxMREjBs3DuPGjcOmTZsAANu2bQOg7szd7RP45XlSxZkDQGRkJGJiYhAZGan3p9Y/2keBVZz5wIEDER4ejvPnz2PNmjV6hwJVMzejh5o0aYIbb7wRr7/+Ovr37w8AmD17Nv72t7/p26jYn/a5V69ejTZt2gCAQ26jVJy5O2b3pzczV60/jc5ctf40mlu1/jSyVlTtz8t5fKrQn0Yfnyr2p5GZq9afDzzwAA4ePIgJEyZg3759+PnnnwH88ul9rTdV60/n3Hv37tUfc/Z5jVJx5u6Y2Z/ezlyl/vRm5ir1pze5VepPo2tFxf683Men2f3pzeNTtf50l/3uu+92mbn2O9xHH33UoT+feeYZvYdqrdaHJnykNp9YOHPmjMu7N5y/1qxZYzjLtGnTBIB89913LvelpqYKANm6datD7q1btwoAWbp0qYhUXfwjJiZGIiMjXXIHBATI448/bmpu++z2uUVE9u7dK9HR0fp9ISEhMnfuXAEgCQkJIuLbmdsrKCiQoKAgt2vFyDtGzMwdFhYmKSkpNa5zT+8YUXHm9rlFRF544QU9iwq5jc5cs23bNgEgo0aNMj27p5kfPXpUAgMDpV69evptzu8YUTG3iOfncgCSkZGh5Fqxf15xlz0mJkZE/GPm2j5Vf3yWlZVJu3bt5Oqrr3aY+cGDBwWAdO/e3fTs1c38tttuE6vV6tChACQsLEw6duzo09wrV66U0NBQycrKEpFfen/cuHESFhamv9NGtf50zm2f3T63RqX+NDpz+9wi5vfn5c5cY2Z/Gp25av15uWtFY1Z/Gl0rKvbn5c7c7P40OnMV+9ObmavUnyIiTz/9tEMeoOqTFgBk7dq1IqJef7rLHR8fr/9vLbdGpf50l93dzO1zi5jfn+5yG5m5xuyfP43MXLX+NJpbRK3+dJfb3VpRsT/dZTcyc7P7011udzNXsT/dZb/mmmvcznzv3r3Stm1bfTvtd7gNGjSQjh07Gs7jyW/iGgvauY5Hjx6NsWPHut3G/nxeNXnnnXfQunVrh/NoaZKTk/HDDz+4XIBKu6jHhQsXAACff/45cnNz3V5kq379+ti2bRseeeQR03NrtNwAkJqaiiFDhmDjxo1499130bZtW4SGhmLq1Kn6hUN8OXN7/+///T/9qKGzpKQkAI7ny9MUFBQgOTnZ1NxFRUVo3bo1jh07Znj/9lScub23334bTzzxBO677z4sWrRIidzezrx79+4Aqi5eDqg582nTpiEsLAw2m00/t+Xp06cBAIWFhcjMzNQvhKdS7pqcP39eybWSnJwMALDZbG4veK+9A0DFteJpnz/++KN+m4oz//zzz7F3717069dP/2QAALRs2RIAkJWVZXr26mYeExOD5ORkfPLJJ7hw4QLatm2LevXqoaioCK1atfJp7gULFqBz585o1KiRw+2DBw/G22+/jV27dqFv377K9aen3EDVO4a03EapkN155vZU6M/aztzM/jQ6c9X683LWiju+7k+ja0XF/rzcmZvdn0ZnrmJ/ejNzlfoTAGbNmoVHH30UP/zwA+bPn6+fBxsAWrVqBUDNnz/tc0dHR2Px4sWYP3++Q26jVJy5PRX60zm3tzM3++dPIzNXrT+N5q6JGT9/GlkrKvanc3ajMze7P51ze5q5iv3pLnv79u31Tw3Zzzw1NRV79+7Fvn379P4MDQ3FI488gh49ehjO48lv4sBCfHw8IiMjUVFR4dUPmu5s374dhw8fxowZM9zen5aWho0bNyI7OxutW7fWbz958qSeBai6oAcAt08ElZWVKC8vVyK3Rsttz2q14vrrrwcAfPrppwCAZs2a6dv7Kru9FStWwGq1oqyszOW+du3awWKx6BcvsXf69Gn069fP1NwRERFo2rTpZf99Ks5cU1RUhIkTJ+L222/H/PnzHV7Y+ePMtTWk4syPHz+OgoICFBQUuPzbPv30UzRt2hQ5OTnK5a5JfHy8kmulffv2sFqtKCoqcnvxJO2igyquFU/7nDZtmn67ijOvrj+BX17QqT7z1NRUl9v69u3r09xnzpxBbGysy+1adu0AiWr96Sm3xtsDmCpkd565RpX+rKuZm9GfRmeuWn96u1Y88XV/Gl0rKvbn5cxchf40OnMV+/NyZq5Cf2piY2Nx/fXX6xcf3bRpExo1aoSrr74agHr96Zzbnn1uo1ScuUaV/nTObc+bmZv582dNM1etP43mrolZP3/WtFZU7E/n7EZmrkJ/Oue2Z59bxf70lN3TzC0Wi0N/fvrpp6isrKx1TgD4TVxjITAwEEOHDsXq1auxd+9el/vPnTtneF/vvPMOAODOO+90e792PuU333zT4fa///3vCAoKQs+ePQH8cvSosLDQZR85OTno3LmzErkBOOR2p7i4GM8++yyAqhdPgG9nbr/PTZs26Qc3nEVHRyMpKQmFhYUoKChwuK+srAzDhw83NXd6ejqCgi7/WJ+KMweqnoTPnTuHG2+8EStWrHA5N5yKMy8sLNTPk2dv9erVAH55l4CKM585cyZ69eqF+Ph4rF27FmvXrkVGRgaAqne8rF27FlFRUcrlzs/Pd3k3l31x33zzzUqulcjISAwcOBDnzp1z+EXy/v37AfxysFXFtWJknyrOXOvPo0ePOtyuna8yMTHR9OxGZq7R3lUUERGBUaNG+TR3q1atsGvXLod33gDAypUrERAQoL+jRrX+9JQbgENuo1TI7jxzQK3+NDpzFfvT6MxV60+juVXrT6NrRcX+9ObxWdM+VcgNOM5cxf68nJlrzOxPT7799ls8/PDD+vO1av3pjnYtRfvcRpmdHXCdOaBWf7rjbuYq9qcnzjNXrT+N5latP91xt1ZU7E9P3D0+a9qn2bndzVzF/nTn3XffrXbmGu13uElJSRg1apTh/XtU65Mp+UhtrrEgInL69GlJSUmRsLAwmTp1qixevFjmzJkjw4cPl9jYWEMZysvLJSEhQbp161btduPHjxcAMmLECLnxxhv181g99dRTDtslJSUJAElPT5eFCxfq58+yWq1y4MABU3PPnz9fmjdv7jb38OHDpU2bNlKvXj158cUXpU2bNvo5Ls2auYjIvHnzBIAMGjTI41q59dZbBYB07txZFi5cqJ9/rFmzZqbn3rBhg8d1/v3330vnzp0lJiZGWrduLTExMZKRkSEAZOTIkaZn9zTzzMxMsVqtYrFYZP78+bJ8+XJZvny5vu6///57U3N7mvmuXbukXr160rp1a4mLi5O//e1vMm7cOP286Y899pi+rWozF3F9TnQ+x6WKuTdv3iw2m02ioqJk/vz58tJLL8l1110nAOR3v/ud6bmre3z+8MMPEhQUJIGBgTJnzhyZM2eO/vz+yCOPmJ7dyFqx36cqz+XVzbxfv34CVJ1XWevP2NhYASCTJ082PXt1M09JSZHIyEhZvHix3qEAZMyYMT7PvXXrVgkMDJQGDRrIjBkzHF6zTJw40WFblfrTOff8+fPlqquucptbtf40OnPV+tPozFXsT2/WuUr9aTS3av3pzeNTtf68nLWiQn96M3PV+tObmavWn3369JHnn39e/v73v+vnru7fv7+UlZU5bKtaf9rnnjhxolgsFgHgklvF/jQycxX708jMVe1Po+tctf40klvF/jT6+FSxP71dK6r0p9GZq9ifztkDAwPdznz48OF6Fvvf4W7atMlQnpr8Zg4siFRdSGPy5MnSuHFjsVqtkpiYKH369JHXX3/dUIYNGzYIAHnttdeq3e7SpUsyffp0SUlJkYCAAAEgf/3rX122Gz16tMTExEjbtm0lNDRUvyDypEmTTM9ttVr1PM6ef/55iYqKEgASGxsrgwcPll27dpk6cxGRbt26SYMGDeSBBx6odq0kJiZK9+7dxWaz6RdmefLJJ03PXV5e7nGdL1myRH+R7fzlfLEVlWauvaDw9GW/XlSa+blz5+Tee++VqKgosVgsEhwcLC1btpSHH37Yb9Z5TS/sVMt95MgRSUlJkcDAQLHZbBIWFiZpaWkCQKZNm2Z67uoenyJVPzTabDYJDw+XyMhIue222/xmrTRo0MBhn6rkrm7mRUVF0qlTJ7FarXp/aj+4q5C9upmnpaVJUFCQ2Gw2vUPNzL19+3YZMGCAJCYm6q9ZZs2a5faHAJX60z63/WsW59wq9qeRmavYn0Zmrmp/erPOVepPI7lV7E+jj08R9frTm7WiUn8anbmK/Wl05ir15+HDh+Wmm26S+vXrS0hIiMTExAgAKS0tddlWpf50zn311VdLt27d/OLnT6MzV60/jc5cxf70dp2r0p9Gc6vWn948PkXU6k9v14oq/enNzFXrT3fZ58yZ43bmzz//vFx99dUO/blr1y5DWYywiHg4SRQREREREREREREREZGT38Q1FoiIiIiIiIiIiIiIqG7wwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZFmR2ANVYLBaP94mID5N4x19zA/6b3V9zA/6bnbl9z1+z+2tuAGhksWArgOYAfgLQE8AJAI0AZCmc3V9n7q+5Af/N7q+5Af/Nzty+56/Z/TU34L/Zmdv3/DW7v+YG/De7v+YG/Dc7c/uev2b319yAf2d3xk8sEBERKSQbVQcTfkLVwYUtAB7u0gVbTcxERERERERERGTPIv52KOQK89ejRv6aG/Df7P6aG/Df7Mzte/6a3V9zA79kb4SqgwrN7e9UOLu/ztxfcwP+m91fcwP+m525fc9fs/trbsB/szO37/lrdn/NDfhvdn/NDfhvdub2PX/N7q+5Af/O7oyfWCAiIlLQCQBjzA5BREREREREROQGDywQEREpqBGA5WaHICIiIiIiIiJygwcWiIiIFBIcHOxwGqSfAHT/33+JiIiIiIiIiFTAaywQERGp5MQJoEcP4MgRoFkzYMsWoHFjICur6r9ERERERERERCbjgQUiIiIiIiIiIiIiIjKMp0IiIiIiIiIiIiIiIiLDeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDOOBBSIiIiIiIiIiIiIiMowHFoiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsN4YIGIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMiwX8WBhXHjxqFJkyYOt1ksFkyfPt2UPEb5a27Af7P7a27Af7P7a27Af7Mzt+/5a3bm9j1/ze6vuQH/ze6vuQH/zc7cvuev2Znb9/w1u7/mBvw3u7/mBvw3O3P7nr9m99fcgH9nv5KUPbBgsVgMfW3ZssUneSorK7Fo0SJ06tQJERERSEhIwIABA/Dll1/WKndpaSmuv/56hIWFITExEQBw6dIln+f2JvuLL76Ibdu24eTJkwgMDHR5YPk6u9HcGzZswIEDB3DmzBkkJSUhMjISnTt31v8uX+f2JvvEiRPxySefICsrCzabDS1btsTDDz9cZ5m9zX65j8/c3Fw0aNAAALBv3z6f5/Yme6dOnbB06VIcO3bM4fa6diVnPnv2bFx99dWw2WwAgBUrVuDEiRNK5l61apXHef/5z3/GPffc49Pc3mT/97//jR9//BEnT5502GdduxJrpbKyErm5uWjWrBlCQkLQrFkz/e9SOTcAlJWVoX///oiIiEBcXBwAoLCw0Oe5L168aDj7woUL8fXXX+PUqVOwWq1X5DnFm+zerPHDhw/j7NmzaNy4McLDw9GuXTsAQHl5uc9zezPzRx99FBs2bEBWVhZCQkLQtGlT/OEPf6izzN5mv9z+LCsrQ9u2bQHA7fPVlc7tzcz79+/v9/25cOFCdOrUCaGhoQCApUuX4vvvv1c2d3X92a9fP5/m9matbNmyBZmZmTh16hRiYmJQr1499OjRo07yXk52b9dKQUEB2rRpg5CQEDRs2BCAOT/H+Wt/fvvtt+xPH+f2Zubsz7rJ7c3M2Z++z61Sf3qzVtifdZP7hx9+8Cp7Xl4ezpw5o/fnmDFj6izz5WQfPnw4mjVrhrCwMNSvXx833ngjPvroI5d9fvPNN3jggQeQlpZ2RTo0qE73VoeWL1/u8Odly5Zh48aNLre3adMGb7zxRp3+EsSdxx57DK+88gpGjx6NBx54ALm5uVi8eDF69OiBbdu2oUuXLnru+fPn45tvvkH//v1x9OhR7N+/HwEBAXj66afRunVrPffkyZOxatUqFBUV4ZVXXsGJEycwa9YsvPfee5g9e7ZPcwNAt27d9NwJCQlYs2YN8vLy8H//9396bgD46KOPkJWVhbS0tDr7JWVtshuduc1mw/bt29G7d2/0798fUVFR+Oyzz7B7926sW7cOM2bM8GluwPjMV65ciSFDhqB169aIjY3F/v378cYbbwCo2yfgK7HO7R+f06ZNQ1FRUZ3l9TY3YHzmCxYsQMOGDZGRkQGr1arfXtflcSVmvmDBAgwaNAizZs3CPffcgw4dOmDChAkIDg5GXl4eGjVqpFzuLl26YMmSJRARt/O+6aabap3Zm9yA8bXy3nvv4euvv8aoUaPQs2dPfZ8AkJ2dXSe5vcnuzVopLi5GXl4ehg0bhmuuuQZff/01jh49ik8++cTnz4mvvPIK/vjHP6JevXqIj4/HgQMH9H+PvTZt2uC5557Dxx9/jMOHD2P27Nm4ePEinnnmGSxfvhyzZs1CcHCwz3Ln5OQAgEPu1NRU/PDDDy7Zd+/ejZ9++gnt27dHYWEhDh48WOuctcludOZNmjTRv2/w4MFo0KABvvrqK/zwww/4xz/+gYyMjDp5gXolZr5p0ybcdNNNSE1NRXx8PI4ePar3Z0FBQa0ze5vdm3Vu35/z5s3D8ePH6yyvt7m9mflHH32E4OBgLFq0SIn+9Hbm48ePx5QpU3D33XfjwQcfxD333IPo6GicPXtW2dwq9ac3a2Xbtm3YunUr+vfvj9tuuw0lJSV4++23AQD79++vk9zeZPdm5vXr18f58+fRu3dvTJ06Ffv27cO8efPw7rvv+vznuN///vc4ePAgunTpgquuugpbtmzBTz/9hJCQEDz33HNo3Lixnlul/nz++ecRHR2t587NzcVHH32ES5cuYfbs2XpuQL3+NDpz1frTm5mr1p/erHOV+tObmavWn97OXJX+9Ca3Sv3pzVpRrT+9mblK/Xns2DG0b98eLVq0QGxsLC5duoSPP/4Yubm5+MMf/oDevXvr+4yOjsZ//vMfJCcnY+rUqbh48SJeeuklAEBFRUWd5PY2e0FBAcaOHYvk5GQUFRVh9erVGDx4MBYvXox7771X3+enn36Kv//97+jQoQOaNWtW9x0qfmLy5MniTVwA8txzz9XJ311WViahoaEybNgwh9uPHDkiAGTKlCn6bdu3bxcA8uKLLzrkbt68uVx77bUO3z9gwABJSkqSvLw8h9wA5LPPPjM1t4jIpEmTBIBL7uzsbLl06ZKIiNxyyy2SkpKiZ1d55ufOnZO9e/e6/F3azA8dOmRqbhHPM3fngw8+EAAydOjQWueubfbq1rlmz549EhQUJDNmzBAAMnz4cNNzi3ieeY8ePSQ1NdXl71N9nYuIPP/882K1WmX79u1+ldsdABIcHCzFxcWm5hZxv1Zq2meXLl1qnbu22T3N/JtvvhEA8uyzzzrsU3tO/P77732au6SkRE6dOiUiIt9++62ew537779fQkND5dixYy65Fy9ebHru3r17u81++vRpKSoqEhHH1zVmPT6Nzry0tFS2bdvmcru2/caNG03P7Wnm7nz33XcCQPr06VPr3HWRvabcZ86ckejoaL0/+/Xrp0RuTzMfO3ashIeHu9yu+joXEXn33XcFgKxZs8avcrujbZ+VlWV6bk9rpWXLlvL73/9eKisr9dvy8vIEgLRq1arWuesiu7vcJ0+elKCgIBkzZozD7dr2H374oU9zb9u2TUpLS/U/a/0SEhIid911l8P3q9SfzrlFRO666y4B4JJbtf40OnPV+tObmbtjZn96s841KvSnNzNXrT+9mblK/Xk5a8WeWf3pzVpRrT+Nzly1/nTngQceEADSunVrh9vd9efGjRsFgNx66621zl0X2cvLy6Vjx44u2T11aF1R9lRI3nB3nit3srOzMX78eCQkJCAkJASpqal46623avy+srIyFBcXIyEhweH2Bg0aICAgQP+YFwB88MEHCAwMdDg6BAATJkzAV199haysLABAfn4+NmzYgMLCQkRFRTlsa7Va8d5775meOyio6gMt9rkBIDk5Gffcc4/fzbx+/fp48cUXPea2P7Kr2swB13Wu/e+SkhKH7VSauX3uqVOnIj09HTfccIPbv1/FmWdnZ6NJkya4ePFitRlUmnllZSWmT58Oq9WKLl26oLy83OOnRFTKDbiu8VOnTgGoemeDdjonM3O7WyvaPvfu3euQXTvll/27X8zMDrjO/D//+Q8A4M0333T7d7777rs+zR0SEqKfErAmS5YsgcViwVVXXeVwe1xcnM/705vcCQkJuP/++5XpT6PZg4OD8frrryvTn97MHFCrP73JruV+8skn0bp1a4wePdrtdqrlBqpO9dmkSRPk5+dXu51q2SdPnozg4GCkp6ejsrLS4+lhVMvtvMZLS0sBACkpKQ6fUlQtd35+Pk6dOoWmTZvqt2k/F5nRn0azf/XVVygvL8dnn33m9v5Vq1b5NHf37t3dftIgNTXV5Z2rKvWnu9wxMTEAXN9xq1p/Gp25av3pzcwBtfrTm3WuUn96O3OV+tObmavUn5ezVjRm9qc3a0W1/jQ6c9X60x3tU2S5ubkOt69evRoNGjTAjTfeqN/Wt29fAFWnJbJnVvbAwEA0btzYJXtCQkKN31sbyp4Kqa6dOXMG3bp1g8ViwYMPPoj4+HisX78eEyZMQH5+frXnqw8NDUXXrl3x9ttv49prr8UNN9yA3NxcZGRkIDY21uGXN7t27UKrVq1cDhZoH1fZvXs3GjdujD179kBEEBIS4vL3JSYmYteuXUrk1mi5vWF2dueZ16R+/fpK5Na4y11ZWYnTp0/j0KFDePLJJwHAoQjNzu5p5kVFRfjyyy+xf/9+ZGZmuvzdZufWOOfOy8tDbm4uIiMjkZCQ4PY8/2Znd575vn37UFxcjJiYGNx7771YunSpfrqso0ePKpvbHe2FRYcOHZTJrdFya/vcsWMHYmJicPz4cX2fAJCWlqZMdueZay+cPX0Ef8eOHT7NbVR2djZKSkoQGxvrcl/Dhg193p9Xgr9l93V/Xo7KykqcPXsWx48f10/zZf/DmKrZL126hKVLl+KLL75w+1hVNXd5eTmOHz+O6OhoxMbGYtSoUcpnz8/PR05ODiIjI/H0009j3rx5+hsL7H9gVC23O59++ikAc/rTGz179sR7772H2NhYZGZmoqSkBPPmzQMAdO3aVdns/tKfZ86cQWpqqv5nf+hPEQHwS694S7WZ10SF/qxp5qr3p6eZq9yf1c3cH/rTeeb+0p9GHp+q9aenteIv/ek8c1X7s7CwUD9F8O7duwEAffr00e/Pzs7G2bNnkZaWpp/y0Z72hkizs3/44YdYv3497rjjDo9/xxVRp59/uIKq+7jG2LFj9dPxaOD0sasJEyZIUlKS5OTkOGw3cuRIiY6O1j8W4smhQ4fkd7/7nf4RHQDSrFkzOXDggMN2qamp0rt3b5fcP/zwgwCQRYsWiYjI+++/LwAkMTHRJXfbtm31283KbZ/dPrdGm3l1p0JSbeb2uTWlpaUCQGJiYqSsrMzU3PbZ3c18xIgRDvts1KiRX8x89OjREhgYKE899ZSIiGzevFkAx1MhqTjz8ePHS8eOHSU+Pl6WLVsmgwcP1rdTeeZr1qwRABIQECAtW7aUJUuWyJIlS/TbtNPbqJZbxPXxmZaWJgBk2rRp+m0qrpVDhw5JXFycyz5VXyurV68WAFK/fn2H79f23a5dO5/mtlfdKSi0+9zl7t69uwCQkpISU3NXd1oebZ1XdyoH1WZun9seUHWqsgsXLpieu6aZ2++zXr16fjPz4OBgGTVqlIiIHD16VADHUzmoOPMnn3xS2rVrJ/Hx8bJy5UqH+dufek21me/cuVPvyoSEBFmwYIGsWLFC3379+vVK5hZxfXwOHTpUAMgTTzyh36biWjlz5owkJSU57LN+/frKPz537Nih//xgT9s+IiLCtNwijq9X3nzzTZd/k4r9qenbt69Lbo2q/Snieeb2ue2p0J+ammauYn+K1DxzFftT42nmKveniOeZq9yf1eUWUbc/NZ7Wisr9KeJ55qr2p3bKY/uv8+fP6/dr/Xn99de7fT7X+tPs7AEBATJs2DCH7M54KqTLJCJYvXo1Bg0aBBFBTk6O/nXzzTcjLy8PO3furHYfkZGRSE1NxeTJk7FmzRosWLAA5eXlGDJkiMMRq+LiYrefQtBO41FcXOzwX3dH6oKCglBcXKxEbvv7vaFCdueZu/Pggw8CAAYOHIigoCAlctvfby8kJAQJCQn46KOPMGPGDJej1ipkdzfzPXv2AACefvppt3+nCrnt79e8+eab6NSpE8LCwjBmzBisW7dO/8SCdtFyFbI7z1x7d0hlZSX+9a9/Ydy4cRg3bpy+/QsvvKBkbmcHDx7U37GgPU+qkNv+fvt9xsTEIDIy0mGfAPTTUKmQ3XnmAwcORHh4OM6fP481a9bg2LFj+mkQLBaLz3vIqJr6E4B+8SqVchul4szd0S6u1rdvX8TExCifOyEhAZ9++ilefvlll1OAqJr98OHDKCsrw/PPP+/2flVzz5kzB2lpaQgLC8PIkSPx9ttvY9asWQCAffv2KZvdvj/XrVuH+++/H3feeSeAqneQzZw5U8nczvLz8/HJJ58A+OV5X9XcYWFhiIqKQnh4ON5//3289dZbSEpKAgCcP39e2ey/+93vUL9+feTl5WHJkiXIzMzE+vXrAQABAQGm9+eFCxcAANdeey3Gjh2r3656fx44cABbt24FAIfcRqk4c3dU6k8jM1e1P6ubucr9Wd3MVe9PTzNXvT+NPj5V68/q1orq/elp5qr258MPP4yNGzdi6dKlSElJAQD9rA/AL/0ZGBjo8e9UIfuAAQNQUVHhkN0n6uLohC/U5hMLZ86ccTn65Pxlf5EZZ2VlZdKuXTt58MEHHW4/ePCgWK1Wefzxx/Xb6vITC2bmts9un1tT0ycWVJy5fW4RkRdeeEHPokJu++zVzVyzbds2AaC/E0PFmR89elQCAwOlXr16+rbOn1jwp5kfOHBAAEivXr1Mz17Tc4vNZnPYJwBp0qSJNG3aVMnczvOeNm2aXzw+tX1effXVDmvl4MGDAlS9A9Ds7NXN/LbbbhOr1apnCAkJEQASFhYmHTt29Glue7X9xMLx48dNzV2bTyyoOHP73CIiq1atEovFolRuIzPXHD58WADIgAEDlMjuLndeXp7YbDaJjo7Wb3N+x6XZub2ZeVFRkQCQzp07K5G9uueWoKAgh9sBSKdOncRqtUp2drZyuUUc5/3WW2+Z2p/ucntaK/3795dGjRo5rJWff/5ZgKqfh1TI7mnmw4cP1zsTgAQGBgoASU5OlujoaNNynzp1SqKiogSAZGdnu/03qdifp06dkmbNmklERITf9Wd1M7fPLaJWf3ozc40q/VndzFXuz8uZuSr9aeS5RcX+9ObxqVJ/1rRWVO7Pmmauan9qtI6xvzi20U8smJ1dRKRfv34uF/Z29++rS7+JayxUVlYCAEaPHu3xCKX9OdScff7559i7dy9eeeUVh9tbtmyJNm3aYNu2bfptSUlJyM7OdtmHds6t5ORkfTsAqKiocNm2oKAAycnJSuTWaLmNUiG788ztvf3223jiiSdw3333YdGiRUrl1tQ08+7duwMA/vvf/yqT3Xnm06ZNQ1hYGGw2m35thdOnTwOoOhdcZmamfpEff5i5di0A7Yi1ijPX/hsQ4PqBtPDwcGRnZyuZ29k777yD1q1b48cff9RvUyG3Rsut7bNfv344ePCgwz4BOFxU2+zs7mYeExOD5ORkfPLJJ7hw4QLatm2LevXqoaioCK1atfJpbqNq6s+4uDj9omUq5TZKxZnb27hxI+6++27ccsst+Pjjj/0mt73mzZsDMKc/jXrppZdQWVmJ8PBwvT+1T8sVFxcjMzNTf55XKbcn2gXjzOhPo2rqz7KyMv1dmSrldrZixQpER0cjLy9Pv03FeR85cgQbNmzAtddei5MnT+q3x8XFATCnP70RFhaGxMREbNy4EadPn0bLli2RlJSE/Px8tGnTxpTceXl5GDBggH4Oa+fXWKr2p5Y7NzcXgwYNwsqVKz3uvzoqztyeSv15uTNXoT9rmrmq/Xm5M1ehP2uauar96c3jE1CnP2taKyr3p5GZq9if7nz77bc4ePAgWrdurfenp7Mt2Gw2hISEKJF92LBhmDRpkp7dF34TBxbi4+MRGRmJiooK/ard3jhz5gwA9y/CysrK9FNeAECnTp2wefNm5OfnO1w4c/v27fr9ANCuXTtYLBb9AWfv9OnT6NevnxK57e/3hgrZnWeuKSoqwsSJE3H77bdj/vz5DgcWVMhtf78R2hpSIbvzzI8fP46CggIUFBQ4XOQLqLowUtOmTZGTk2N6bvv7q3PkyBEAVWUIqDnz9u3bw2KxePyhMT4+Xsnc9rZv347Dhw9jxowZmDZtmn67Crnt77ffp/zvwlrOtBcXKmSvbubuLmTWt29fn+Y2qmHDhggJCXHbn9nZ2ejUqZOSuY1SOXtpaSnS09NxzTXX4L333tOfC1XP7YkZ/WnU8ePHcenSJZw8edKlP7/44gs0bdoU3333nXK5PSkoKABgTn8alZycDJvNhrKyMpf7CgoKYLPZ0LRpU+Vy2zt16hQ2b96McePG4a233tJvV3HeKvbn5WjZsqX+ZgKg6pQgZvRnSUkJBg0ahIMHD+LWW2/F6tWrXb5Pxf60z71p0yasWLHC679To+LMNSr1Z13M3Kz+NDJzFfuzNjM3uz+NzFzF/vTm8Qmo059G1oqq/entzFXpz+poB5kaNmyI+Ph4j6d/SkxMBKDGaxbt4If9AbIr7TdxjYXAwEAMHToUq1evxt69e13uP3fuXLXf36pVKwDAqlWrHG7fuXMnfvzxR3Tu3Fm/bdiwYaioqMDrr7/usO2SJUvQtWtX/R3P0dHRSEpKQmFhoV4WmrKyMgwfPtz03Npits9tlNnZAdeZA1UP1HPnzuHGG2/EihUrXI6qm53b3cwLCwv187Tb056otaPAZmcHXGc+c+ZM9OrVC/Hx8Vi7di3Wrl2LjIwMAFWfuFi7di2ioqKUm3l+fr7LD10igpkzZwIAWrRoAUDNmUdGRqJRo0YoLS3FgQMHHLbNyspCv379lMxt75133gEA/dycGrNzu1sr2j6PHj3qsk/glxcZZmcHqp+5RnshEhERgVGjRvk0tzdSUlJQXFysvyNHc/78eZ/3Z11TNXteXh7Onj2LJk2a4OOPP9bfQady7vLycv0cr/a++eYbAOb0p1FTpkxx6c/FixcDADp27Ii1a9eiRYsWyuUuKSlxeV0LQO9+M/rTG02bNkVFRQU2btzocPuBAwfQu3dvWK1WJXNrVq1ahcrKStx1110Ot6s47xYtWiAgIMClP7V3FpvRn7Wh/SInKCgI9913n09zV1RU4I477sBXX32F999/X5+dOyr1p3Pua6+9ttp910TVmavUn0ZnrmJ/Gp25av1pdOYq9qc361yl/vQmt0aF/jS6VlTsz8uZucbM/jx79qzHPKGhoWjbtq1++9ChQ3HixAmHX/r/61//AvDLm/TMzl5WVoZly5a5ZL/i6vTESldQba6xICJy+vRpSUlJkbCwMJk6daosXrxY5syZI8OHD5fY2Nga//5+/foJAElPT5eFCxfKtGnTJDY2VsLDw12uzj18+HAJCgqSxx57THr27Kmfb27r1q0O29166636+fIWLlwozzzzjABVV/w2O/fixYslMTFRALjk/v7776Vz584SExMjrVu3lpiYGMnIyBAAMnLkSNOze5p5ZmamWK1WsVgsMn/+fFm+fLksX75c/zu+//57JWe+a9cuqVevnrRu3Vri4uLkb3/7m4wbN06CgoIEgDz22GPKzlzE9fHpfI0FFWe+efNmSUxMlLZt20pcXJy89NJLct1117mcc1HVmd92221isVgkKSlJ5syZI3PmzBGg6rz5J06cUDa3tlYSEhKkW7duIqLOc3l1z4naPsPCwhz2CUAmT55sevbqZp6SkiKRkZGyePFiefHFF6VNmzYCQMaMGWNK7nnz5klGRobcf//9+uMtIyNDMjIyJDc3V99u2LBhEhAQIM2bN5fXXntNZs+eLQCkQYMGUlJSYnruZs2a6dntc2dmZur92bVrV30bADJkyBBlZ56fny9hYWECQP7yl7+49OeXX35pem53M79w4YKEh4dLixYtJDY2VhYtWiSTJ0/W/y325y9VbeYirv3pfI5os3O7m/nRo0f114dxcXEyd+5cGThwoP7vnDZtmhLZPc18xIgREhgYKJGRkfLcc8/JK6+8oj9/7t69W9nc2lpJS0uT5ORkqaioMLU/jT4nTpw4UYCq60LNmzdPZs+eLY0aNRIAMm7cOCWye5p5mzZtJCIiQhYsWCBz587Vn9PNeC6fOnWqAJBBgwbJ8uXLpW/fvgJAf662p1J/Oud2zm5Ptf40OnPV+tPozFXsT2/WuUr9aXTmKvanNzNXqT8vZ62o0J/ePCeq1p/ezFyl/hwyZIj07t1bpk+fLm+88YZkZGRITEyMAJCXX37ZYZ/Hjx+XkJAQCQoK0vtT+5n/mWeeUSL71Vdf7TZ7Zmam/lrGvkMzMjJk2bJlNWaqyW/mwIJI1cVLJk+eLI0bNxar1SqJiYnSp08fef3112v8+4uKimTGjBnStm1bCQ0NlejoaLn11ltl165dLtsWFxfLo48+KomJiRIQECAAZMOGDW5zJyYmSvfu3cVms0l8fLwAkCeffNL03CEhIdKgQQO3M1+yZIlecM5fHTt2ND27p5lrv9D29GW/XlSa+blz5+Tee++VqKgosVgsEhwcLC1btpSHH37Yb9Z5TQcWzMrtaeZHjhyR4cOHS3h4uP4L47S0NFm0aJHfzDwpKUn69u0r4eHhEhkZ6fJDgKq5tf8/XnvtNRFR57m8uufEoqIi/cJk9vtUJXt1M09LS5OgoCCx2WwSGxsrgwcPNjV3SkqKx+foo0eP6tuNHTtWkpOT5aabbpKwsDD9BeCf/vQnpXNX10POr2NUyq79QO7pa+zYsUrmLi0tlalTp0psbKxYLBaxWq2SkpIiEyZM8Jt1XtMvRlTLfeHCBRk9erRERkaKxWKRkJAQSU1N1X956Q8zb9iwoaSnp0tUVJSEhoYKAJk4caLyuZOTkwWA/PGPfxQRc/vTaO6ysjLp0qWLWK1WiYiIkIiICOnVq5dfZL/uuuvEarXqr7P69OljWu4ePXpU+xxtT6X+9Ca3av1pNLtq/Wk0t4r96e06V6U/jeZWsT+9nbkq/Xk5z4kq9Kc3uVXrT2+yq9SfK1eulL59+0pCQoIEBQVJbGysfoDGndtuu01sNpven3fddZdS2fv27Svr1q1z2Wd1HdqjR48aM9XEIuLhxFxEREREREREREREREROfhPXWCAiIiIiIiIiIiIiorrBAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYUFmB1CNxWLxeJ+I+DCJd/w1N+C/2f01N+C/2Znb9/w1u3PuawF8qf1B4dzAr2fm9pj7yvDX7P6aG/Df7Mzte/6a3V9zA/6b3V3uhgAKAOT5WW6NyvMG/De7v+YG/De7v+YG/Dc7c/uev2b319yAf2d3xgMLRET0q9YIwHKzQxARERG50QjACac/bwFw1pQ0RERERMbxVEhERPSrpf1w3hzATwC6m5qGiIiIyNEWVL1eARxftzQwKQ8RERGRUTywQEREv0oN4XhQoSeAr0zMQ0REROSsOaper1wL19ctRERERCrjqZCIiOhXqQC/nEagJxxPM0BERESkgp9QdTDhS7s/9wRftxAREZH6+IkFIiL6VcoH0B9AD/CHcyIiIlLTGDd/5usWIiIi8gcW8bfLTRMRERERERH9GjRvDhw58sufmzUDtmwBGjc2LRIRERGRETywQEREREREREREREREhvFUSEREREREREREREREZBgPLBARERERERERERERkWE8sEBERERERERERERERIbxwAIRERERERERERERERnGAwtERERERERERERERGQYDywQEREREREREREREZFhPLBARERERERERERERESG8cACEREREREREREREREZxgMLRERERERERERERERkGA8sEBERERERERERERGRYTywQEREREREREREREREhvHAAhERERERERERERERGfarOLAwbtw4NGnSxOE2i8WC6dOnm5LHKH/NDfhvdn/NDfhvdub2PX/N7q+5Af/Nzty+56/Z/TU34L/Z/TU34L/Zmdv3/DW7v+YG/Dc7c/uev2b319yA/2Znbt/z1+z+mhvw7+xXkrIHFiwWi6GvLVu2+CRPZWUlFi1ahE6dOiEiIgIJCQkYMGAAvvzyy8vK/e9//xuHDx/G2bNn0bhxY4SHh6Ndu3YAgPLycp/n/uGHHwxnf/TRR7FhwwZkZWUhJCQETZs2xR/+8Ic6y+xt9stdK2VlZWjbti0AuOzTF7m9mXn//v2xdOlSHDt2zOH2unYlZ75w4UJ06tQJoaGhAIClS5fi+++/Vza3p3n/+c9/Rr9+/Xya25u1smXLFmRmZuLUqVOIiYlBvXr10KNHjzrJeznZvV0rBQUFaNOmDUJCQtCwYUMAwKVLl3ye29vsZ8+exenTpxEWFobExERMmTKlzjJ7m92b3CdPnsTPP/+Mdu3aITAw0OWFkoq5N2zYgAMHDuDMmTNISkpCZGQkOnfurP9dvs7tTfaJEyfik08+QVZWFmw2G1q2bImHH364zjJ7m/1y+zM3NxcNGjQAAOzbt8/nub3J3qlTJ7/vz9mzZ+Pqq6+GzWYDAKxYsQInTpzwaW5vslssFo8z//DDD+sktzfZvZm5iKCgoMBhnwCQlZWldO7Kykrk5uaiWbNmCAkJQbNmzfS/y9e5t2zZwv70cW5vZj516lT885//RFZWlt6fCxcuNC27NzP/73//i1OnTiE+Pl7vUAAoLCxUOrc9s/vTm7XC/qyb3N7MnP3p+9wq9ae32dmftc/tTXbV+lOzc+dODB48GHFxcQgLC0O7du3w2muvOWwze/ZsdOvWzaE/H374YZw7d65OMgfVyV6ugOXLlzv8edmyZdi4caPL7W3atMEbb7xRpw98dx577DG88sorGD16NB544AHk5uZi8eLF6NGjB7Zt24YuXboAAP70pz/hn//8J1q0aIHY2Fhs27YNP/74IwDgD3/4A3r37g0AaNKkif59gwcPRoMGDfDVV1/hhx9+wD/+8Q9kZGTUSXEbzX3s2DG0b99ez33p0iV8/PHHyM3NdcgNAJs2bcJNN92E1NRUxMfH4+jRo3jjjTcAVP1SsK7U9cyd18q8efNw/PjxOsvrbW5vZv7RRx8hODgYixYtgtVq1W8fM2aMKdm9nfn48eMxZcoU3H333XjwwQdxzz33IDo6GmfPnlU295IlSyAibud90003+TS3N2tl27Zt2Lp1K/r374/bbrsNJSUlePvttwEA+/fvr5Pc3mT3Zub169fH+fPn0bt3b0ydOhX79u3DvHnz8O6772L27Nk+zQ380kPnz5/HY489hvLyclRWVrr0UEVFBf7973/j6quvxn333YcTJ07gpZdeqpO8l5PdPt/58+fxyCOPoLKyEg0bNsRf/vIX/b42bdogMTERZWVliI6ORnJycp1nvhK5bTYbtm/fjt69e6N///6IiorCZ599ht27d2PdunWYMWOGT3PbZ69praxcuRJDhgxB69atERsbi/379+v9WZcH0K7EWrHvz2nTpqGoqKjO8nqb2z57TTNfsGABGjZsiIyMDCX605uZL1iwAIMGDcKsWbNwzz33oEOHDpgwYQKCg4ORl5eHRo0a+Sy3ffbqZl5aWoqSkhKEh4c7dOiGDRuwYsUKNG/evNaZvc3uzcxjY2Nx/vx5DBw4UN/nE088gSVLlmDSpEkO81Apd3FxMfLy8jBs2DBcc801+Prrr3H06FF88sknpjwnAlWvlbRf0HzxxRfYu3cvFixYgMjISH0b1frz6aefxuzZs/XsWu777rsPHTp00LOr1p+ammaelZWFp59+Gr1798ZDDz2EuLg4fPbZZ3jggQdMy+7NzFNSUpCWlobU1FRERkZi//79ePnll/Hmm29i+vTpCA8PVzK3av0JGHt8qtaf3sxctf4Eap65iv3pzcxV6k9vcqvWn48//jhefvllNGnSBF27dsWuXbuwf/9+DBw4EKNGjdK3U60/ly9fjj179ujZAwMDcfDgQdx6662orKzUs6vYn0ZmrmJ/AsA///lPDBo0CJ07d8azzz6LiIgI/PTTTy4HUHfs2IFOnTph5MiRen++8cYb+OSTT7B79+7a96f4icmTJ4s3cQHIc889Vyd/d1lZmYSGhsqwYcMcbj9y5IgAkClTpnj8Xi13x44dpXXr1vrtpaWlsm3bNre5AcjGjRtNzS0i8sADDwgAh9yefPfddwJA+vTpU6vMmisxc3tnzpyR6OhomTFjhgCQfv36mZ5bxPPMx44dK+Hh4S7bq77ORUTeffddASBr1qzxq9zuaI/PrKwsU3OLeF4rLVu2lN///vdSWVmp35aXlycApFWrVrXOXdvsnmZ+8uRJCQoKkjFjxjhsr838ww8/NC33HXfcIb1795bk5GS3PTRgwABJSkqSvLw8/bY33nhDAMjo0aNrnbu22Rs2bCgAJDU11eX+7OxsuXTpkoiI3HLLLZKSkqLE47O63OfOnZO9e/e6fI+2Vg4dOmRq7urWijsffPCBAJChQ4fWOrfIlVsrmj179khQUJDen8OHDzc9d3Uz79Gjh9t/j+rrXETk+eefF6vVKtu3b1cut7frvE+fPgJAnnnmmVrnFrkyM/e0T+25paZeNiv3N998IwDk2WefdZv7+++/92nuzZs3CwB5//339ds8/RynWn86Z6/u50+V+tPozD315x/+8AcBIA899JDp2S/nZ34AsnLlSuVzq9Cf3jw+VetPb2auUn96M3N3zOxPozNXrT+N5latP/Py8iQhIUHS09OloqKi2uyq9adzdn/pT6MzV7E/3WX3hvYzaF30p7KnQvKGu/NcuZOdnY3x48cjISEBISEhSE1NxVtvvVXj95WVlaG4uFj/OJemQYMGCAgI0E/tUp3GjRsjNzdX/3NwcDBef/11j7nt31lsVm7tExP2uTXOM9f+d0lJicN2Ks3cPveTTz6J1q1bY/To0W6/V8WZl5aWokmTJsjPz692H6rNfPLkyQgODkZ6ejoqKys9flxZtdzOa7y0tBQAkJKS4vAuF9XWSn5+Pk6dOoWmTZvqt0VFRQGAw7uNzMwOuM78q6++Qnl5OT777DO3269atcqU3J9//jk++OADvPrqq273mZ+fj40bNyIuLg4dOnTQb7/77rsBVJ3Gyp4Z2W+44QaP+3366af1UwlUR6Xc9evXx4svvqhcf9a0VjQq9qeRtaLlnjp1KtLT0z1uq+LMs7Oz0aRJE1y8eLHG7VSZeWVlJaZPnw6r1YouXbqgvLzc47tcVZy5/To/deoUNm/eDAAICnL8sLRKM9f26amH7PepUu7//Oc/AIA333zT7f3vvvuuKbmBqk8yezrFq8r9qWWv7hPxKvanltvTzOvXr4/U1FSXHkpPTwcAl1MiqDbz6n7mt39NqWpulfpTy13TKZhV7E8tu6eZq9qfWu6aZq5if2rZPc1c1f6sKbdq/fnOO+/gzJkzmDVrFgICAlBYWAgRcdmniv3pnL2srMzjflXqT6MzV7E/3WX35kw+2r/D3e8evaXsqZDq2pkzZ9CtWzdYLBY8+OCDiI+Px/r16zFhwgTk5+dXe47j0NBQdO3aFW+//TauvfZa3HDDDcjNzUVGRgZiY2Nx7733unxPYWGh/rEqAFi/fj3uuOMOw3nr169veu7du3cDAPr06eN2/5WVlTh79iyOHz+uf0zM/peZqs780qVLWLp0Kb744gu3p5tSdebl5eU4fvw4oqOjERsb6/BROBWyA64zz8/PR05ODiIjI/H0009j3rx5+gtT+8JTLbc7n376KQA4lLeKa6Vnz5547733EBsbi8zMTJSUlGDevHkAgK5duyqRHXCduXbgxtMp4Hbs2OHz3BUVFXjooYcwceJEtG/f3u0+9+zZg/LyctSvX9/hh67g4GAAVT8QaMzK7vyDiLf8LbcZ/WlkrdirrKzE6dOncejQITz55JMA4PAiVdWZFxUV4csvv8T+/fuRmZnpcr+qM8/Ly0Nubi4iIyORkJCAe+65R5nsnma+b98+FBcXIyYmBvfeey+WLl2qny7r6NGjpuc2ss41q1atcvuDjmozDw0NRf369fHzzz9jxYoV+j61+7R9qpZbxf4Eqk53ePHiRQQGBrr8gAyo25/22bWZfvfdd7jmmms8/h2eqDZzT06fPg0ACAsLMz27kZnn5OSgvLwchw4dAlC19nv27Kl0bpX60z53TWtFtf60z+5p5ir2p31ubx6fKvSnfXZPM1exP43kVq0/N23ahKioKGRnZ2PIkCE4ePCg3v0lJSX6tUJU7E932QHg/vvvx1//+lc9u1GqzdwTM/vTXfbw8HCMGTPG7cxFBD///LPen08++SQCAwP1/qyVWn/mwUeq+yjN2LFjJSUlxeE2OH2UZsKECZKUlCQ5OTkO240cOVKio6OlqKio2r//0KFD8rvf/U7/WBQAadasmRw4cMDt9pMmTXLYdtiwYXL+/HlDuYODg+XChQtK5AbgklvLbr9NvXr1/GbmwcHBMmrUKBEROXr0qACOp0IyO7e7mT/55JPSrl07iY+Pl5UrVzrM3/6je2Znd575zp07BYAEBARIQkKCLFiwQFasWKFvv379eiVzi7g+PocOHSoA5IknntBvMzu3u7Vy5swZSUpKctimfv36yj8+d+zYIQAkJibG4fu07SMiInye+29/+5tER0fL2bNnRUTcnvbj/fffFwDSv39/t8/n9qcwMyu71p/uPs5uv849fRRV9dwiVacX1NZPWVmZqblF3K8VzYgRIxz22ahRI7+Y+ejRoyUwMFCeeuopEfnlY+b2p3JQcebjx4+Xjh07Snx8vCxbtkwGDx6s71vlma9Zs0bvz5YtW8qSJUtkyZIl+m3ax/NVnLmI42M0LS1N7yWVZy4ikp6eLsHBwS5dO3nyZGVzr169Wu96e9q+27Vr59Pc27Ztk6FDh8qbb74p69atkzlz5khISIgAkJ07d+rbqdifztm7desmAMRmszlkF1GrP43O3F320tJSadu2rWk/U3g7c60znV9Tqpxbpf70Zq2o1p9GZ65af9bm8Wl2f3qzzlXqT6O5VevPDh06SFhYmISFhclDDz0kq1evlvbt2wsAGTlypL6div3pnL1///769vbZRdTqT6Mzd5fd7P50l/2hhx7ymP3UqVMuP4O+++671WYx6ldxKqSaiAhWr16NQYMGQUSQk5Ojf918883Iy8vDzp07q91HZGQkUlNTMXnyZKxZswYLFixAeXk5hgwZgpycHJftH374YWzcuFF/N3FFRUWNF2bULk7at29fxMTEmJp76dKlSElJAeD5gpIJCQn49NNP8fLLL+Oqq65yuE/VmR8+fBhlZWV4/vnn3f6dqs58zpw5SEtLQ1hYGEaOHIm3334bs2bNAlD1rgyzs3uauXYEvbKyEuvWrcP999+PO++8E0DV0diZM2cqmdtZfn4+PvnkEwDQj/yqulbCwsIQFRWF8PBwvP/++3jrrbeQlJQEoOrij2Zn9zTz3/3ud6hfvz7y8vKwZMkSZGZmYv369QCAgIAAFBcX+zT3zz//jGnTpuHZZ59FfHy8x/0VFxcDAAIDA93er33cWcXsRvhL7gcffBAAMHDgQAQFBSmdOyQkBAkJCfjoo48wY8YM/RMWGlWz79mzB0DVx5fdUTX3m2++iU6dOiEsLAxjxozBunXr9Hdcahc2UzG7fX/+61//wrhx4zBu3Dj9/hdeeEHJ3M4OHjyIHTt2YOTIkQ63q5rdarXCarU67BOoetdoTk6OkrkHDhyI8PBwnD9/HmvWrMGxY8fw3nvvAah6F6av+7N79+744IMPMH78eAwePBhPPvkkhg8fDgB46qmn9O1U7E/n7Glpafoc7bMboeLM3XnwwQf1nyUCAgJMz17TzAMDA7Fx40a9Q4FfXgurmlul/vRmrajWn0Znrlp/Xu7jU4X+9Gadq9SfRnOr1p8XL15EUVER7r77brz22mu4/fbbceONN+pz1D6lpWJ/OmfXLjY+adIkh+xGqDhzd8zuT3fZX3vtNY8zj4uLc+hP50+81Ertj034Rm0+sXDmzBmXI6fOX/YXlnVWVlYm7dq1kwcffNDh9oMHD4rVapXHH3+8xtz9+vVzuaCqfe5Vq1aJxWJRJrd9dufcztlFRA4fPiwAZMCAAaZn9zTzvLw8sdlsEh0drW/r/IkFf5p5UVGRAJDOnTubnt3TzL/99lsBIEFBQQ7bA5BOnTqJ1WqV7Oxs5XKLOM77rbfecnmHjqprpX///tKoUSOHtfLzzz8LAGnbtq3p2aub+fDhw/V38ACQwMBAASDJyckSHR3t09z33XeftGjRQkpLS/XbavOJBTOz1+YTC/6Q+4UXXjD18Wl0rbjLLlL1rioA+ifpVJz50aNHJTAwUOrVq6ff5vyOS3+a+YEDBwSA9OrVy/TsnmauPbfYbDaH2wFIkyZNpGnTpn4x82nTpgkA+e6775R5jHqaeVlZmcTExEhkZKTD7UDVu1wff/xxJXOLiNx2221itVr1DFqXhoWFSceOHZV5zRIcHCzl5eUiomZ/eso9cuRIh+wiavVnddmdc9tn1/ozIyNDmexGZ67R8nz00UdK5latP6vLXt1a0ZjZn55yO89ctf6sLnt1M1ehPz3ldp65av1pNLeIWv2ZmpoqAGTr1q0u2QHI0qVLRUTN/nTOruXeunWrQ3YRtfrT6Myds6vQn+6yi4jbmbuj/Qz60UcfVbudEb+Jayxo56UbPXo0xo4d63Yb+/OmO/v888+xd+9evPLKKw63t2zZEm3atMG2bdtqzDBs2DBMmjQJBw8eROvWrR3u27hxI+6++27ccsst+Pjjj5XKDQDffvut29z2tCOS//3vf5XJ7jzzl156CZWVlQgPD9fPbam926K4uBiZmZn6kUZ/mLl24RbtiLWKM09OTgbwyxFce+Hh4SgrK9OPkqqU29mKFSsQHR2tXx8AUGPegONaOXLkCDZs2IBrr70WJ0+e1LeJi4sDAGRlZSmT3d3Mw8LCkJiYiI0bN+L06dNo2bIlkpKSkJ+fjzZt2vgs96FDh/D666/j1VdfdZhjRUUFACAzMxNRUVGIi4vTPw2iPQ6dRUZGAvDdzN1l1y74XlZW5pDdCNVzv/3223jiiSdw3333YdGiRUrkBtyvFU+6d+8OwPf96c3Mp02bhrCwMNhsNr0/tXOKFhYWIjMzUz+vqz/MvHHjxgB835/ezLym/szOzvaLdf7OO++gdevW+rsFNSrO/PPPP0dubq7bc1/Xr18f27ZtwyOPPKJcbgCIiYlBcnIyPvnkE1y4cAFt27ZFvXr1UFRUhFatWinR+0DVO8sLCwsRFRWlXH9Wp3Hjxg7ZjVAhNwCPuS9evKj35//93//h2WefVSq7NzOPiIjAihUr9HOnq5Rbpf6siZF5m9Wf1XGeuUr9WZPqZm52f1bHeeYq9ac3uQG1+jM5ORk//PCDx2twXLhwAQCU7E9P2Rs0aOCQ3QgVcmvc5ValP2s78+7duyMpKQkrVqzArbfeWu22NflNHFiIj49HZGQkKioq0LdvX6+//8yZMwB++QHKXllZmf5Ro+poD3r7X0wCVReMSU9PxzXXXIP33nvP4aIfKuTWOOf2RLsAjgrZnWd+/PhxXLp0CSdPnnS4yDQAfPHFF2jatCm+++4703Nrapp5QUEBgF8uFKPizJOTk2Gz2VBWVuY2v81mQ9OmTZXLbe/UqVPYvHkzxo0bh7feeku/XYV5a7Tc2j5FxO12WtGpkL26mbds2RItW7bU/3zx4kX07dvXZ7m1HzimTJmCKVOmuGzbtGlTTJ06Fa+++iratWuHoKAgl9M/aR/LT0xMBOC7mVeX/eDBgw7ZjVA5d1FRESZOnIjbb78d8+fPdziwoEJuAF7N29f96c3Mjx8/joKCAhQUFLj056effoqmTZsiJyfH9NyAsZkfOXIEgO/705uZt2/fHhaLxe0+CwoKEB8fr0RuwPPMS0tLcezYMf10JfZUyO488+o6tLKyEuXl5UrmtpeamuqyX1/2Z01sNhsiIiIAQLn+rM6RI0ccshuhQm4AbnMfP34cP//8M4YOHYr58+crmd2bmZeXlyMvL0/J3Cr1Z02MzNus/qwpk312lfqzJp5mrkJ/Vsd55ir1pze57anQn2lpadi4cSOys7PdvtlROy2iiv3pKbv25ghvTqOpQm77LPZU6s+6mHlJSYnh3/VW5zdxjYXAwEAMHToUq1evxt69e13uP3fuXLXf36pVKwBV59iyt3PnTvz444/o3LmzftvZs2fd7mPZsmUIDQ1F27Zt9dvy8vJw9uxZNGnSBB9//LH+DnRVcmu/hLTPXV5e7vbI1zfffAMA+jsEzM4OuM58ypQp6NWrF+Lj47F27VqsXbsWixcvBgB07NgRa9euRYsWLZSbeUlJiX4QwV5GRgYAoEWLFgDUnDlQ9QuHiooKbNy40WHbAwcOoHfv3rBarUrm1qxatQqVlZW46667HG43e97u1kqLFi0QEBCAo0ePOmyrfTJHe5Fhdnag+pk7/xuDgoJw3333+Sx3u3bt9OcI+y/tnaFr167FhAkTAADR0dHo27cvjhw54vBievny5QB+eZFqZvYBAwYAAK666iqH7EaomvvMmTM4d+4cbrzxRqxYscLlXWkqrpXCwkIUFRW5/F2rV68G4Pv+9GbmM2fOdOlPrYO6d++OtWvXIioqSrmZ5+fn6wdsNCKCmTNnAvB9f3oz88jISDRq1AilpaU4cOCAw36zsrLQr18/Jde5vcLCQgDQr61kT8WZa/vUctvLyclB586dlcztjnbwPiIiAqNGjfJp77vbl/bLj5tuukl/vlatP6vb14cffuiQ3Qizc7ubOVD1bsitW7fCZrO57U8VsgOuMy8sLPT4i8OSkhJcc801SuZWqT897cvdWlGtP6vbl/PMVepPT/vy9PjUqNCf1e3LeeYq9ac3ud0xsz9HjBgBoOr6Js6CgoLQs2dPAGr2p6fsf//73x2yG6FCbgAuuVXrT6Mzr+5n0AsXLuif9quVWp9MyUdqc40FEZHTp09LSkqKhIWFydSpU2Xx4sUyZ84cGT58uMTGxtb49/fr108ASHp6uixcuFCmTZsmsbGxEh4e7nB17iFDhkjv3r1l+vTp8sYbb0jXrl31c2m9/PLL+nb5+fkSFhYmAOQvf/mLLF++XJYvX67/HV9++aWpuTMyMiQmJsYl94ULFyQ8PFxatGghsbGxsmjRIpk8ebL+b7E/F5hqMxdxXSvO11hQceZHjx6VmJgYad26tcTFxcncuXNl4MCB+r9x2rRppmevbuYjRoyQwMBAiYyMlOeee05eeeUVAaquu7B7925lc2trJS0tTZKTk6WiokKZ5xVPa0VEZOLEiYL/nVd03rx5Mnv2bGnUqJEAkHHjxpmevbqZt2nTRiIiImTBggUyd+5cfdshQ4b4PLc7ns4nvmPHDgkICJDg4GBZuHChPPPMM2Kz2UxbL86qOy/34MGDJSYmRjIyMqR169b6uurVq5d8+OGHSubOzMwUq9UqFotF5s+f79Kf33//vam5RdyvlV27dkm9evX05/K//e1vMm7cOAkKChIA8thjj+nbqjZzEdf+dD5HtJm5RdzPfPPmzZKYmCht27aVuLg4eemll+S6667Tn4NUf3zedtttYrFYJCkpSebMmSNz5swR/O+8vydOnDA1t0j111i4++67JSAgQLp166bf5g8zT0pKctknALFarfo+VcydkpIikZGRsnjxYnnxxRelTZs2AkDGjBmjb+Or3L169ZKBAwfKzJkz5fXXX5eHH35Yf57bt2+fwz5V60/n7B07dhQAEh0d7ZJdpf40OvPMzEyJjo6WwMBAiYuL0/tT69D77rtP2Znv2rVLQkJCJDIyUl577TW9Q7Vtc3JylMwtolZ/Gl0rKvanNzNXqT+9eU4UUas/vZm5Sv3pTW6V+lNEZPz48QJARowYIfPnz5fmzZsLAHnqqacctlOtP52z33jjjfrzhXN2lfrT6MxV7E932YcPH+6SXfsZ9IEHHnDoz6CgIGnSpInen7XxmzmwIFJ1IY3JkydL48aNxWq1SmJiovTp00def/31Gv/+oqIimTFjhrRt21ZCQ0MlOjpabr31Vtm1a5fDditXrpS+fftKQkKCBAUF6Rd/WbduncN22i+0PX2NHTvW1NyxsbH6LyPtlZaWytSpUyU2NlYsFotYrVZJSUmRCRMmKD9zEWMHFszK7WnmFy5ckNGjR0tkZKRYLBYJCQmR1NRUmT17tt/MvGHDhpKeni5RUVESGhoqAGTixInK59Z+afLHP/5RRNR5XvG0VkSqLvjTpUsXsVqtEhERIREREdKrVy9lslc38+uuu06sVquEh4dLZGSk9OnTx7Tc7lT3S7T+/ftLSEiI2Gw2iY+P1ztLhezV/TLK/odEs3vIaG7tB3JPX/YzV2mtnDt3Tu69916JiooSi8UiwcHB0rJlS3n44Yf9Yq0Y+cWIWblF3M/8yJEjMnz4cAkPD9d/oZCWliaLFi3ym5knJSVJ37599edFAC4XdFNp5pq+ffsKAHnttdf02/xh5qNHj5aYmBiHfQKQSZMmKZ07LS1NgoKCxGazSWxsrAwePNi0ec+dO1e6dOkicXFxEhQUJElJSdKqVSu/6E/n7Nobpw4dOuSyT5X60+jMa+rPHj16OGyv0szPnTsnrVq1kqCgIAkPD9c7FHA8MK9abhG1+tPoWlGxP72duSr96e1zokr96c3MVepPb3Kr1J8iIpcuXZLp06dLSkqKWK1WfY7uqNSfztkDAgIEgPz1r3912U6l/nTO7WnmKvanu+wtWrRwmbn2M+jVV1/t0J8PP/ywnDt3rsY8RlhEPJyMm4iIiIiIiIiIiIiIyMlv4hoLRERERERERERERERUN3hggYiIiIiIiIiIiIiIDOOBBSIiIiIiIiIiIiIiMowHFoiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsN4YIGIiIiIiIiIiIiIiAwLMjuAaiwWi8f7RMSHSbzjr7kB/83ur7kB/83O3L7nr9n9NTfgv9m/sljQAEBPACfsbm8EIEvh3P46b8B/s/trbqAqexSASADZTvepnN1fZ+6vuQH/ze6vuQH/zc7cvuev2f01N+C/2f01NwD8ZLGguf2f8cvrdJWz++vM/TU34L/Z/TU34N/ZnfETC0RERFRrDQA0B7AFVQcT8L//bjEpD9GVEAVgA4Ct+GWdExEREalmjJs/n3C3IRFRLfDAAhEREdVaT1S9E6o5gO02G+5q1gxb/vdnol+LSHg+iEZERESkiuVu/szXK0RU13hggYiIiGrtBH45uJBcUoJ/HDmC5v/7M9GvRTYcD6J9HhCAGwID+ckcIiIiUor2Orw7fnndsgU8uEBEdYsHFoiIiKhOnID7j10T/ZrYH0RrWlmJzysq+MkcIiIiUop2TYWv4PimiC2mJSKiXyMeWCAiIqI60QjuP3ZN9Gvj7iAaERERkSp64pdrKti/KeKsSXmI6NfJIv52uWkiIiJST1YW0LMncOQI0KwZsHw5MGZM1Z/5UoN+bezXu4brnIiIiFR24gQQGQlER5udhIh+JXhggYiIiIiIiIiIiIiIDOOpkIiIiIiIiIiIiIiIyDAeWCAiIiIiIiIiIiIiIsN4YIGIiIiIiIiIiIiIiAzjgQUiIiIiIiIiIiIiIjKMBxaIiIiIiIiIiIiIiMgwHlggIiIiIiIiIiIiIiLDeGCBiIiIiIiIiIiIiIgM44EFIiIiIiIiIiIiIiIyjAcWiIiIiIiIiIiIiIjIMB5YICIiIiIiIiIiIiIiw3hggYiIiIiIiIiIiIiIDOOBBSIiIiIiIiIiIiIiMuxXcWBh3LhxaNKkicNtFosF06dPNyWPUf6aG/Df7P6aG/Df7P6aG/Df7Mzte/6a3V9zA/6bnbl9z1+z+2tuwH+zM7fv+Wt2f80N+G925vY9f83ur7kB/83O3L7nr9n9NTfg39mvJGUPLFgsFkNfW7Zs8UmeyspKLFq0CJ06dUJERAQSEhIwYMAAfPnll3WSOzc3Fw0aNAAA7Nu3z+e5vcneqVMnLF26FMeOHXO4va5dyZnPnj0bV199NWw2GwBgxYoVOHHihE9ze5PdYrF4nPmHH35YJ7m9ye7NzEUEBQUFDvsEgKysLJ/n9ib7pk2bsHv3bmRnZyMkJATNmjXDzJkz6yyzt9m9XeelpaW4/vrrERYWhsTERADApUuXlM598uRJ/Pzzz2jXrh0CAwNdStuXuceNG2c4+9SpU/HPf/4TWVlZiIyMROfOnbFw4ULTsnsz8//+9784deoU4uPjYbPZ0LJlSwBAYWGhz3N7M3P753OtP/2lhzZs2OD2ufwf//iH0rk1KvSnN2uF/Vk3ub2ZOfvT97lV6k9vsrM/6ya3t9k17E/f5Nao0J/eZGd/1k1ub7KzP32fm/1ZN9nZn3XHm+w7duz4/+ydd3gU5fqGn02yqaRBQgo99AQQCAIiGqQJCEgTQSkRpAgIWLCAAtIEVI6KIuABRIx0UCmCoKiYQ5EiEIoBKQmBBGJII519f3/kzLizLbMk2fn2d977unIhs7Pf3jx+M89mZ2cGPXr0gJ+fH3x9fdG9e3f88ccfZut16tTJ4r+pR48eFeLsViGjVALr1q1T/P3LL7/Evn37zJY3bdoUn3/+OQwGQ6X6TJs2DUuWLMGwYcMwYcIEZGZmYsWKFYiJiUF8fDzatm0re585cwYffPAB6tatC1dXVyQmJqJ3794wGAwYOnSoRe+ZM2ciLy9PM28AeO2112Tvdu3a4eTJkzh//jx69eolewPAsmXLUKNGDcydOxd6vV5ePnz4cE3c7cl82bJl6NOnD+bPn48xY8agRYsWGD16NNzd3ZGVlYWaNWs6zBtQl3lhYSEKCgrg4+MDIpIz37NnD+Li4lC/fv1yO9vrbk/mgYGByMjIQK9eveQxX3/9daxZswbjxo1T5FHZ3oD6eb506VKcOnUKsbGxaNeuHQ4fPoy333673K736z5z5kzcunVLft5vv/2GhIQEuLu7IygoCIsWLQJQmvnEiROxYcMG5OXlYcmSJbh+/Trmz5+PTZs2YcGCBcJ6h4aGori4GP7+/ggPD68Qz/v1HjduHLy8vBTPldzDw8Nl7+TkZEyfPh2dO3fGiy++iKpVq2Lv3r2YMGGCZu72ZF6nTh1ER0cjKioKvr6+OH/+PD744AOsWrUKs2fPho+Pj8O81WYuuUsdOm3atErpT3vc7cm8UaNGcHNzw8KFC+X1hw8fjocfflhob5H6U+1cEbE/7clcpP60Z/sUrT8//PBDTJ8+HV5eXujSpQvOnDmD8+fPAwBatWqFl19+GYB4/WmPt0j9mZycDG9vb9nbx8cHe/fuxY0bNxTeIvanPZmL1J9qM5fcRepPezIXqT/t8RapP9XOFRH7057MRepPe7ZP0fpz7ty5mDNnDqpWrYrOnTvj2LFjuHjxIjw9PTFnzhyEhYUBEK8/7fEWqT9PnDgBvV4vexMRvvnmGxQUFGDx4sWyt4j9aU/mIvWn2swld5H688SJE+jYsSNq1aqFWbNmwWAwYNmyZYiJicHRo0fRuHFjxbg1a9bEu+++q1hWYXOenISJEyeSPboAaNasWRXy2sXFxeTl5UWDBg1SLL98+TIBoMmTJ8vLsrKyKCQkhPr370/37t1T5X3mzBlyc3OjOXPmEAB66qmnNPcmsp55TEwMRUVFmS13hswXLVpEer2ejhw5Ipw3kX3zvEuXLgSAZsyYobm7NW9rYwIwG1MLbyLLmR89epQA0Ntvv61Y/sorrxAAGj9+fLm97XU3RfIGQPPnz1c81rNnTwoLC6OsrCx5mbTu3r17hfVOSUmhoqIiIiJ64oknqE6dOpptn5YYMGCAmfft27cpISHBbN3nnnuOANCLL76oubutzC0hrbt+/XpNvYksZ26MaX+KMl9sZW6pQ53BW6T+tERZc8UYLfvTFGuZi9aflrCUuYj9OX/+fAIg76ulzEeMGEEAKCMjQ15XpP60x1uk/jT1NnY39haxP+3J3BJa9afazI0RpT/tyVyk/rTHW6T+vJ+5YoyW/ak2c9H6U23mIvZnr169KDAwkNLT0xXeVapUoQEDBiieL1J/2uMtUn+aehMRxcbGEgCFt4j9aU/mltCqP9Vmbowo/WnJ/caNGxYzt/YZbkUh7KWQ7MHSda4skZKSglGjRiEkJAQeHh6IiorC6tWry3xecXEx8vPz5VPoJKpXrw4XFxfFN7i+/vprpKWlYf78+XBxcUFxcXGZ3lOmTEH//v3xyCOPCON99+5dEJHVsVNSUlC3bl3k5ubadBApc4PBgNmzZ0Ov16Nt27YoKSmxepRRxMyN5/nNmzdx4MABAICbm/LEI5Eyl8bcu3evxceNxxQp84MHDwIATp8+rdi3DBkyBACQkJCgWN8R7tbQ6XR45pln5L9nZ2djz549uHv3Lvz8/BTr6vV6bNq0SUhvAJg+fbp8KqQttPJOTEwEAIV3UFAQoqKizHqof//+AIDbt28L4Q5YztxWf2ZmZmrubSlzY/cHH3zQZn9q6Q5YzvzChQtITExESUmJzQ4VyVu0/rREWXNFlP60hmnmovWnJSxlLmJ/ZmdnA4DZumFhYXBxcYG7u7u8nkj9qdYbEKs/rXkDUHiL2J/2ZC5Sf6rN3NhdlP60J3OR+lOtt2j9eT9zRZT+VJu5aP2pNnMR+/PgwYPo2rUrqlWrplg3JiYGO3fulLdD0fpTrTcgVn9a8pa+vW/sLWJ/2pO5SP2pNnNjd1H605J7WFiYxcwlyurP+6bSDllUMLa+yT1y5EiqU6eOYhlMjhqlpqZSzZo1qVatWjRnzhz67LPPqG/fvgSA/vWvf5X5+u3atSMfHx/66quv6Nq1a3Tq1CkaNGgQVatWjf766y95vYEDB5Kfnx/t27ePGjVqJB/BGj9+POXn55t5BwcHk6enJ125coUOHDhAgPKMBS293dzcCICZd0xMDOl0OvnfFhISQm+99ZbwmZ85c4YAUEBAAI0ZM4bc3d3ldUeMGCGEt7XMiZTzfMmSJRaPjoqWORFRUFAQ6XQ6xZgAyMvLSx5TtMwXLFhAAGjgwIGKfcvZs2cJANWvX9/hmZvywgsvEAB6+OGHFct/++03AkDBwcGK5QCoVq1a1Lp1ayG9iZRz3No3RrTyLioqIg8PD9U9tHLlSgJAo0aN0txdTea3b9+mmzdv0q+//koASKfT0fnz5zX1LivzmJgYAqDoT1Hmi63MQ0JCCIDcQdLf33rrLWG9RetPU+zZPrXuT1NszRWR+tMUa5mL2J/ff/89AaC+ffvSyZMnaeTIkQSA/Pz8aOrUqfJ6ovWnWm8isfrT1DspKYm6d+9OAMy8Td2JtO3P+8lchP60N3OR+tOezEXqT7XeovVnebZPrfvTnrkiUn+qzVzE/nR3d1fMU+kzuaeeeooA0KFDh4hIvP5U600kVn+aehu7m3qbuhNp25/3k7kI/Wlv5iL1pyV3IrKYeUxMDOn1ekV/vvXWW/LZOuXlf+bAwujRoyksLExxmggR0ZAhQ8jf35/y8vJsvv7FixepdevW8sQBQBEREXThwgXFei1atCBvb2/y9vamF198kXr06CGvP2TIEMW6w4YNI1dXV3rzzTeJiCweWNDKe+vWrdS8eXOL3qNGjaIHHniAgoOD6csvv5Q3EtEz37ZtGwEgFxcXatiwIa1Zs4bWrFkjLzt16pSwmRMp53l0dDSFhYUJnzkRUf/+/RVvoqWfiRMnau5tLfOtW7cSAOrYsaNi37J8+XKzN02OcjfliSeeIAC0bNkyxfLNmzcTAAoNDVUsB0CRkZHyctG8idS9sdPKe8eOHfL6ljB2LywspMjISAKUpzOLmnnNmjXNtk/j0y9FzDwvL498fHzI39+fiMjqGzsRM2/QoAH5+/vT1q1bFR0aGRkprLdo/WmKPdun1v1piq25IlJ/mmItc1H7c+7cueTl5aVY1/RSHiL2pxpvIvH605K3s/SnPZmL1J9qMxexP9VmLlp/qvEWsT/vd/sUoT/VzhXR+lNN5iL2Z/PmzalRo0ZUUlJCRP98Jle7dm0CQFu2bCEi8fpTrTeRWP1p6k1ENH78ePk5xt6m7lr3p72Zi9Kf9mQuWn9aci8sLLSY+ahRo2j27Nlm/Tl48GCbLmr5f3EppLIgImzduhV9+vQBESE9PV3+efzxx5GVlYUTJ07YHMPX1xdRUVGYOHEitm3bhmXLlqGkpAT9+vVDenq6vF5ubi7y8vIwYsQIfPzxx/KNjcaNG4cNGzbg4sWL8rpnzpwBUHr6lWjeAwYMwKOPPgoAZt6rVq1Cy5Yt4e3tjeHDh+Pbb7/FmDFjAADXr1/X3N1a5tIpPwaDAT/++CNiY2MRGxsrj7N48WJhMzcmMTERx48fl0+LlBAxc6D09Ee9Xq8YU/o3pqenC5l5r169UKdOHRw7dgx5eXm4du0aNm3ahBkzZgAoPYXM0ZmbIl2CYvDgwYrl+fn5AEovq2GKm5sb8vPzhfRWg5beX3/9NVxc1FXmpEmTcO7cOQCQnyNy5q6urti3bx927NiBOXPmAACKioo097aV+cKFC2EwGODv72/1+aJm/vDDDyMgIAADBgyQOxQAzp07h8OHDwvpLVp/mqJ2+xShPy05AZbnikj9aYq1zEXtz7p16+LRRx/FypUr0aNHDwDAggUL8Mknn8jriNifarzVoKX31q1b0bRpUwAo01uE/rQnc5H6U23mIvan2sxF60813iL25/1sn6L0p9q5Ilp/qslcxP6cMGECEhMTMXr0aJw7dw5///03gNLLYgH/9KZo/anWWw1aeickJGD//v3y47a8te5PezMXpT/tyVy0/rTkPmLECIuZr1q1CrNmzVL055gxY7Bp0yYcPnzYpo8qyn9swjGU54yFtLQ0s6Nhpj/btm2z+trFxcXUrFkzmjRpkmJ5YmIi6fV6eu211+RlUVFRBIB++eUXhfcvv/xCAGjt2rVERHTlyhVydXWlatWqyc81PWNBS29jd2NvCdPML1y4QADoscce09zdWubSkXRPT0/FmACobt26VK9ePafIfObMmQSAjh07Jvw8Ly4upoCAAPL19TXL3MXFhV577TVhM09ISCB/f3/5MQ8PD/roo48IKD11zNGZG5OTkyNfwskUNd8YEdGbqOxvjGjp7e3tLfvYcl+8eDEBoLlz5wrjrjZzCclnx44dQmZ+5coV8vLyoocfflh2t/SNEWfMfO7cuUJ6i9afpt5qt08R+tPU3VrmovWnqbetzEXrz/Xr15OXlxclJycT0T+9HxsbS97e3vI3ykTrT7XeRGL1p6m3sbupt7G7CP15v5lLaNWfajMXsT8rKnNH96e9+xVR+vN+t08R+lNt5qL1pz2Zi9afRETTp08nvV6vGH/GjBkEgLZv305E4vWnWm8isfrTkndwcLD838bexu4i9Of9Zi6hVX+qzVzE/rTk3qZNG4uZW0L6DHfu3Lk211OD8q47/08xGAwAgGHDhmHkyJEW12nRooXV5//6669ISEjAkiVLFMsbNmyIpk2bIj4+Xl4WHh6Os2fPWrzZBgDcuXMHADBz5kx4e3vD09MTV69eBQCkpqYCAO7evYurV6/KN/LR0ltC8rZGrVq1APxzVEzEzMPDwwHA4jfsfHx8kJKSIoS3hLXMv/76azRu3BjR0dGK5SK4m2b+66+/IjMz0+K/MSgoCPHx8XjppZc095YwzjwqKgr9+vXDvn37sHHjRkRGRsLLywtTpkyRb5DjyMyN+eabb+RvrZgSFhYGALh3757ZYzk5OQgPDxfSWw1aeufl5aFx48a4du2a1fFzc3Px+uuvY/z48Xjrrbfw9ttvC+F+P5lXqVIFcXFxaNOmjWbe1jKfOXMmatSogdDQUFy9ehVXr16V+xMovemXwWBwuswBICMjQ0hv0frT1FvN9gmI0Z+m7tYyF60/Tb1tZS5afy5btgytWrVCzZo1Fev27dsXX3zxBU6ePImuXbsK159qvdUggjcA5OXlWfQWpT8rInMt+lNt5iL2Z0XNc0f3p1pv0frzfrZPQIz+VJu5aP1pT+ai9ScAzJ8/H6+++irOnj2LTz/9FBs2bJAdGjVqBEDM3z/VeKtBS29/f3+sWLECn376qVVvUfrT1P1+Mtfq9081mYvYn5bcmzdvLl8Rp6zMpc9wMzIybK6nhv+JAwvBwcHw9fXFvXv3VL8BNyYtLQ2A5R1lcXGx4pfC6Oho7Nu3DykpKWjcuLG8/MaNG7ILACQlJSEnJwc5OTmoV6+eYszdu3ejXr16SE9P19xbQvK2xuXLlwEA3t7e8vpau5tm3rx5c+h0OquFFxwcLIS3hKXMCwsLce3aNfl0MdP1tXY3zVwak4jMxjQYDCgpKRHCW8JS5nq9Hh07dgRQum0CQEREhLy+o9yNiYuLg16vR3FxsdljzZo1g06nQ2Fhodljqamp6Natm5DeatDSu0qVKmb7amOSkpLw999/Y+DAgfIbEVHc7yfzkpISZGVlCZl5UlISLl26hEuXLgGA2TofffQRZs+e7XSZA3B4Dxljy1u0/jT1Lmv7BMTpT1N3a5mL1p+m3moyF6U/09LSEBgYaHE94J/LS4jWn2q91SCCt4Spt0j9WRGZa9GfajMXsT8rap47uofUeovWn/Zun4A4/ak2c9H6834yF6U/JQIDA9GxY0ds2LABALB//37UrFkTTZo0ASBef6r1VoOW3sZY8hapP03d7ydzLX//LCtzEfvTmrvazKXPcMv6rFcN/xP3WHB1dcXAgQOxdetWJCQkmD1++/Ztm8+XjvRIG4fEiRMn8Oeff6JVq1byMukauatWrVKs++9//xtubm7o1KkTAGDevHl47LHHEBwcjO3bt2P79u2YO3cuAKBDhw7Yvn07/Pz8NPcGoPDOzs42Kwwiwrx58wAADRo0ACBm5r6+vqhZsyYKCwtx4cIFxbrJycno1q2bEN6AMnNj7t69CwB45plnzB4Twd00c2lMyduY9PR0tGrVSghvwHrmEvn5+fI3AJo1awbAsZkbj7l//375zaUp/v7+CAsLw927d5GTk6N4rLi4GE899ZSQ3mrQ0rt///5wc7N8LP7XX3/FL7/8Ak9PT8TFxVn8VpqImd+9e9fqL+wFBQVo06aNkJnPmzcP27dvV3So1J8A8PTTT8PHx0fIzLOzs83eKBr/4vv4448L6S1af5p629o+JUTpT1N3a5mL1p+m3moyl9C6Pxs1aoSTJ0/K97OQWL9+PVxcXORvjonWn2q91SCCNwAzb9H6U23movWn2sxF7E+1mYvWn2q9RetPe7ZPCVH6U23movXn/WQuoXV/WuP333/H1KlT5X22aP2p1lsNWntL94A09RatP61hmrlo/WkJS5mL2J+W2Lhxo1nmZX2G+/jjj9scUxXlvpiSgyjPPRaIiFJTU6lOnTrk7e1NU6ZMoRUrVtC7775LTz31FAUGBpb5+t26dSMA1L9/f/rss89o5syZFBgYSD4+PmZ35x41ahQBpXfYfvTRR+XrXb355ps2vU3vsaCl96effkr169c38z5w4ACFhoZSZGQkVa1ald5//316+OGHza4tJmrmTz75JOl0OgoLC6N3332X3n33XcJ/r294/fp1ITOXGDFiBLm4uFD79u3lZc6QeVhYmNmYAEiv18tjipj5U089RU2bNqVq1arRe++9R02bNiUPDw9NMyciWrp0KQGgPn36WN0n9u7dmwBQq1at6LPPPpOvsxcRESG0d9++fSkgIIDmzp1LjRs3poCAAAJK793y3Xffaeq9Z88eiz109epV8vf3J1dXV6patSqtW7dO/gFA48ePl9cVLfOTJ0+Sh4cH+fr60scff0yffPIJxcbGEgDy9/eXr/kqWuYSxh1q6RqXWrpby/zAgQPk6elJfn5+9Omnnyo6tHXr1sJ6E4nXn8beZc0V0frT2N1W5qL1p7G3rcxF689ffvmFXF1dqXr16jRnzhzFe5bnn39eMaZI/WmPt0j9aer96aefUu3atc28RexPtZmL1p9qM5cQqT/VZi5af9qzfYrUn/bOFZH6057MRepPezIXsT+7dOlCixYton//+98UGRlJAKhHjx5UXFysGFO0/lTrLVp/Gns///zzpNPpCIDCW9T+VJO5iP2pJnMJ0frT1N3V1dUsc+kz3JdeesmsP8eOHVumjxr+Zw4sEJXeSGPixIlUq1Yt0uv1FBoaSl26dKGVK1eW+fp5eXk0Z84cioyMJC8vL/L396fevXvTyZMnzdYtKiqi2bNnU506dcjFxYUA0L/+9a8yvS0dWNDKW6/XyzcOMuby5cv01FNPkY+Pj/yGKDo6mpYvX+40mYeFhVHXrl3Jx8eHfH19CYDZzVFEylyia9euBIA+/vhjeZkzZD5s2DAKCAhQjAmAxo0bp7m3rcwXLVpEfn5+BIACAwOpb9++dPLkSU0zJyJq3749Va9enSZMmGBznxgaGkodOnQgT09P+QZEb7zxhtDexgcpTX9GjhypqXdJSYnFHjJ+Q2HpJyYmRrG+SJnfvn2bGjVqRG5ubuTj40Pu7u7UsGFDAkDTpk3T3Nta5hJq3thp5W4t88uXL1OdOnXI1dWVPD095Q4FQDNnzhTWm0i8/jT2LmuuiNafxu62MhetP429bWUuYn8eOXKEevbsSaGhofJ7lvnz55v90ihaf6r1Fq0/jb2N32uZ/qIrYn+qyVzE/lSTuYRo/akmcxH70579ikj9ac9cEa0/1WYuWn+qzVy0/rx06RJ1796dgoKCyMPDQ/7QvbCw0GxMkfrTHm+R+tPUu0mTJtS+fXun+P1Tbeai9afazCVE6k9L7u+++65Z5tJnuHXr1lX05/Lly8lgMJTpowYdkYWLzzEMwzAMwzAMwzAMwzAMwzAMw1jgf+IeCwzDMAzDMAzDMAzDMAzDMAzDVAx8YIFhGIZhGIZhGIZhGIZhGIZhGNXwgQWGYRiGYRiGYRiGYRiGYRiGYVTDBxYYhmEYhmEYhmEYhmEYhmEYhlENH1hgGIZhGIZhGIZhGIZhGIZhGEY1fGCBYRiGYRiGYRiGYRiGYRiGYRjV8IEFhmEYhmEYhmEYhmEYhmEYhmFU46a1gGjodDqrjxGRA03sw1m9Aed1d1ZvwHnd2dvxOKu7s3oDAP7rnuTmhhgiXL13T35IZHdnzdxZvQHndXdWb8B53dnb8Tiru7N6A87rzt6Ox1ndndUbcF53Z/UGnNedvR2Ps7o7qzfg3O6m8BkLDMMwDCMg5958Ex2HDkVISIjWKgzDMAzDMAzDMAzDMAr4wALDMAzDCEj0Rx/h/SlT0KJFC61VGIZhGIZhGIZhGIZhFPCBBYZhGIYRiA4A/gIQnJ0Nn969EZSfr7USwzAMwzAMwzAMwzCMAh0528WbKhlnvc6Vs3oDzuvurN6A87qzt+NxVndn9QZK3WsC+BlAfQCXdTo8SoQUiO3urJk7qzfgvO7O6g04rzt7Ox5ndXdWb8B53dnb8Tiru7N6A87r7qzegPO6s7fjcVZ3Z/UGnNvdFD5jgWEYhmEE4zqATig9cyGNCDna6jAMwzAMwzAMwzAMwyjgMxYYhmEYRlSuXwd8fQF/f61NGIZhGIZhGIZhGIZhZPjAAsMwDMMwDMMwDMMwDMMwDMMwquFLITEMwzAMwzAMwzAMwzAMwzAMoxo+sMAwDMMwDMMwDMMwDMMwDMMwjGr4wALDMAzDMAzDMAzDMAzDMAzDMKrhAwsMwzAMwzAMwzAMwzAMwzAMw6iGDywwDMMwDMMwDMMwDMMwDMMwDKMaPrDAMAzDMAzDMAzDMAzDMAzDMIxq+MACwzAMwzAMwzAMwzAMwzAMwzCq4QMLDMMwDMMwDMMwDMMwDMMwDMOohg8sMAzDMAzDMAzDMAzDMAzDMAyjGj6wwDAMwzAMwzAMwzAMwzAMwzCMavjAAsMwDMMwDMMwDMMwDMMwDMMwquEDCwzDMAzDMAzDMAzDMAzDMAzDqOb/xYGF2NhY1K1bV7FMp9Nh9uzZmvioxVm9Aed1d1ZvwHnd2dvxOKu7s3oDzuvurN6A87qzt+NxVnf2djzO6u6s3oDzujurN+C87uzteJzV3Vm9Aed1Z2/H46zuzuoNOLd7ZSLsgQWdTqfq5+eff3aIj8FgwPLly9GyZUtUqVIFISEh6NmzJ/7zn/+U23vBggVo0qQJPD09AQBxcXG4fv26Q73tcdfpdFi7di2uXbumWAYA3333XYV42+NuT+ZEhJycHMWYAJCcnOxwb3vc9+/fjz/++AMpKSnw8PBAREQE5s2bV2HOEsXFxXjnnXcQERGheJ2SkpL78pbmeWFhITp27Ahvb2+EhoYCAIqKioT2vnHjBv7++280a9YMrq6uZgXiSG973KdMmYIffvgBycnJ8PX1RatWrfDZZ59p5m5P5qdPn8bNmzcRHBwMT09PNGzYEABw9+5dh3vb6y6RmZmJ6tWry/vEiqQyMt+zZ4/FfflXX33lcG973Q0GA7KysuT+lPbn2dnZDndX671hwwar/fnOO+9gzJgxQno7qj8rY644e38WFxejR48eqFKlCqpWrQpAm32iPd7p6enIyMhAdHQ09Hq9pvvD3Nxc1e5vvPEGfvzxR1y/fh0+Pj5o1qyZ08yVxMREpKamIiQkBB4eHqhXrx6A0k5ytLc9mRv3Z3FxMSIjI52mP3/77TeL+/JPPvnE4d72Zm68P/fy8kK1atUAAKmpqQ53t8fbVn9269ZNWG8AyMvLQ/v27REQECDnnZiYWCHO9njbO1fOnz8v92eNGjXw8ssvV5izve7O2p+///67avfPPvsMhw8fxs2bNyutP+1xV+v9008/4dKlS7h16xZq1aoldygAi+/hRPEWrT/tmSvcnxXjbW/mIvXn77//jkmTJiEqKgo+Pj6oXbs2Bg8ebLFbbP27KqI/3co9QiWxbt06xd+//PJL7Nu3z2x506ZN8fnnn8NgMFSqz7Rp07BkyRIMGzYMEyZMQGZmJlasWIGYmBjEx8ejbdu2AIC5c+dizpw5qFq1Kjp37oxjx47h4sWL8PT0xJw5cxAWFiZ7L1u2DH369MH8+fMxZswYtGjRAqNHj4a7uzuysrJQs2ZNh3mfOHECer1e9iYifPPNNygoKMDixYtl78LCQhQUFMDHxwdEBL1eDwDYs2cP4uLiUL9+/XI72+tuT+aBgYHIyMhAr1695DFff/11rFmzBuPGjZPHdIS32swBYOnSpTh16hRiY2PRrl07HD58GG+//Xa5XU0ZNmwYNm/ejFGjRqFNmzby6yQlJWHlypXyeuvWrcOnn36Ko0ePokePHrhy5QrOnz8PFxcXTJ8+HY0bNwZQmvnEiROxYcMG5OXlYcmSJbh+/Trmz5+PTZs2YcGCBcJ6h4aGori4GP7+/ggPD68Qz/v1BoD27dvL3iEhIdi2bRuysrLw1ltvyd7JycmYPn06OnfujBdffBFVq1bF3r17MWHCBM3c7cm8Tp06iI6ORlRUFHx9fXH+/Hl88MEHWLVqFWbPng0fHx+HeQPqMpfcpR6aNm0a8vLyyu1ZHnd7Mm/UqBHc3NywcOFC+fnDhw/Hww8/7HBvQH3mDRo0QEpKCgoLC9GjRw+0aNECd+7cwauvvoqCggKHu6vNvG3btlizZo2iP4HSzAGge/fuQno7qj8rY66I1p9LlizByy+/jGrVqiE4OBgXLlwAYP6+t2nTppg1axZ27tyJS5cuYcGCBcjNzcWMGTOwbt06zJ8/H+7u7kJ6t2rVCnv37oVOp0NERESFfnhmr3d6ejoAKLyjoqJw9uxZhXtBQQHGjBmDtm3b4vnnn0d4eDgOHTqEWbNmAQCIyOHu9mTevHlz1K9fHy1btkRgYCCuXLmCefPmYeXKlXjttdcq5H1MRWcuuUv9uXTpUiQlJZXbszzu9mTeoUMHJCcnY9WqVfLy4cOHV9gH3PZ425s5ESErKwv9+vXDpEmTcPfuXUydOrVCP3StjMxF6k97vFu2bIm1a9eibdu2WLhwIQoKCvDSSy9h/fr1GDRoEAYMGOAwb3vmypYtW3D06FH0798f3bt3x7lz57B06dJyu96v+4MPPojExES0bdsWtWvXxs8//4y//voLHh4emDVrFmrVqgVAvP5ctGgR/P39Ze/MzEzs2LEDRUVFWLBggewNAH/88Qf++usvNG/eHHfv3q2U/rTHXW3mdevWlT/n6Nu3L6pXr45Dhw7h7Nmz+OqrrzB37twK+dC7MuaKSP1pz1wRrT/tyVyk/rQ3c5H6c9GiRYiPj8dTTz2FFi1aIDU1FZ988glat26Nw4cPywf3APNuAoBjx47ho48+qpj+JCdh4sSJZI8uAJo1a1aFvHZxcTF5eXnRoEGDFMsvX75MAGjy5Mnysl69elFgYCClp6crvKtUqUIDBgxQPH/RokWk1+vpyJEjwnkTEcXGxhIAM29LdOnShQDQjBkzNHe3lrm1MQGYjamFN5HlzI8ePUoA6O2331aM+corrxAAGj9+fLm9y3odnU5Hp06dkpcdOXKEANB7771HRP9kXr9+fXrooYcUz+/ZsyeFhYVRVlaWvEzKfO/evcJ6p6SkUFFRERERPfHEE1SnTp0K3T7L401ENG7cOAKg8L59+zYlJCSYvdZzzz1HAOjFF1/U3N1W5paQ5sr69es19SaynLkxZ86cITc3N5ozZ47sLcJ8sZV5TEwMRUVFKZaJ4k1kPXNL/SmS+/3Mc3d3d8rPzxfS2xH9WRlzRcT+LCgooJs3bxIR0e+//y5naIkXXniBvLy86Nq1a/Iyaf0VK1YI652amkp5eXlE9M+c0mrbtOTduXNnM/fCwkKKj483e6133nmHANDw4cOFcLf3dyEA9O6772rubSlzY9LS0sjf31/z/rQn85EjR5KPj49imUje1jLfuHEjAaBt27YJ634/8zw5OVlY74YNG9KDDz5IBoNB4a3X66lv376ae1uaKzdu3CA3Nzezfd/SpUsJAA0ZMqTc3va6x8fHU2Fhofx3qV88PDzo2WefVTxfpP409SYievbZZwmAmbel/pTctdg+1WZurUOlzPft2yektzW06k975oqEKP1pT+Yi9ac9mYvWn5bcExMTVc/z0aNHk06nq5D+FPZSSPZg6TpXlkhJScGoUaPk05yioqKwevXqMp9XXFyM/Px8+bR/ierVq8PFxQVeXl7ysoMHD6Jr167yKTESMTEx2LlzJ3JzcwGUXi5n9uzZ0Ov1aNu2LUpKSqx+y1Urb+nbwcbeEsaZ37x5EwcOHAAAuLkpT4IRKXNpzL1791p8TeMxRcr84MGDAIDTp08r5vmQIUMAAAkJCYrXul936XWkcY1fh4iwceNGedmWLVvg6uqKsWPHKtYdPXo0Dh06JF8aIzs7G3v27MHdu3fh5+enWFev12PTpk1CegPA9OnT5Uvx2EIrb2lbM/YOCgpCVFSU2T6xf//+AIDbt28L4Q5YztzWvtz4dFSRMjd2f/DBB9G/f3888sgjVh1Ey/zChQtITExESUmJ2X5eBG9LmRsMBnz00UeoUaMGBg8ebLM/tXQH1M3zmzdvAij9Fox0SUTRvB3Rn5UxV0TsTw8PD/mSgGWxZs0a6HQ61K5dW7G8atWqDu9Pe7xff/11NG3atMz1RPJ2d3dHhw4dhOpPezIXqT/t8Zbc69evj8aNG2PYsGFW1xPN/bfffkNeXh7u3btn8xJ8onkvWbIEQUFBeOmll2AwGGx+y1I0d9N5XlhYCACoU6eO4kx/0byTk5ORkJBg9o1td3d3h/enWu9Dhw6hpKQEN27cEKY/O3ToYPFMg6ioKJw/f16xTKT+tOQdEBAAAGbeISEheOGFFyr1s63KyNzd3R0rV6606m28rkjegFj9ac9ckdxF6U97MhepP+3JXLT+tOTesGFDi5mbUlhYiK1btyImJqZCrpQj7KWQKpq0tDS0b98eOp0OkyZNQnBwML7//nuMHj0a2dnZmDp1qtXnenl5oV27dvjiiy/w0EMP4ZFHHkFmZibmzp2LwMBAxS+2hYWFijcIEt7e3igqKkJCQgLat2+Pc+fOIT8/HwEBARg7dizWrl0rX3P+ypUrwngDUHhbYsOGDRYvRaW1u2nmXl5eCAoKwt9//424uDh5TOn1pDG19gaUmUtvmk0P2nh7ewP450Op8rpLr2PqJL3O8ePH5WUnT55Eo0aNzA4WSJfC+OOPP1CrVi2cOXMGRAQPDw+z1wsNDcXJkyeF9FaL1t4SZXlL1/yTxhbB3Vbm6enpKCkpwcWLFwGUXhOwU6dOQnhLmHpfvXpVvozZ1atXLT5Ha3drmRcXF8PHxwdFRUXyQdF79+4J4y0heZ87dw43btxAq1atcPHiRdm9efPmZs/R2l3NvmXDhg0AgBYtWgjr7Yj+rIy5ImJ/qiUlJQUFBQUIDAw0e6xGjRoO78+Kxlm8tezP++Hvv//GvXv3FJdE6NKli9De6enpyM3NxYcffmj1UhmiuhMR/Pz8kJeXJ2+rxvcQE807OzsbR48eRePGjXHz5k34+/sjNzdXvqa4MaK5W2L37t0AtOlPewgNDcXVq1exdOlS9OnTR75kY2FhIaZMmSKktzP1Z1paGqKiouS/O0N/0n8vrxcUFFTmv88SomVeFtK/U2RvUfvT1lxxhv60lrnI/Wkpc2fpTyJStX3u3r0bmZmZePbZZ22up5pyn/PgIGxdCmnkyJFUp04dxTKYnI4yevRoCgsLU1x2hohoyJAh5O/vL59yZo2LFy9S69at5dOLAFBERARduHBBsV7z5s2pUaNGVFJSovCuXbs2AaAtW7YQEdG2bdsIALm4uFDDhg1pzZo1tGbNGnmZdIqLVt5EROPHj5efI3lLGGceHR1NYWFhwmdORNS/f39yd3dXjAmAJk6cqLk3keXMt27dSgCoY8eOinm+fPlyAkDBwcEV4i69zrp16xTLpddp1qyZvCwqKoo6d+4s/13K/OzZswSAli9fTkREmzdvJgAUGhqqGBMARUZGystF8yZSznFrl0LSytvY3dTb1L2wsJAiIyPNTqkTNfOaNWuabZ/Gl18RMfO8vDzy8fEhf39/IiI6cOCAxVNRRcy8QYMG5O/vT1u3bqUvv/yS+vbtK2+fWnsbuxt7S/3p4eFBbm5ucn82bNiQAOXlbUTM3PQ9S3R0NAGgmTNnCu1d2f1ZGXNFxP40xtblM6THgoKCFMsBUIcOHQgAFRQUCOdNpJzj1i6FpKW3rcvymG6fXbt2JQD0+uuvC+FelreHh4di++zRo4cQ3tYyNxgMFBQUJF8S4cqVK8LNF2uZN2vWjPz8/Gjjxo20fv16GjlyJAGgWrVqUXFxsebeljI/ceKE3J8uLi60bNkyiouLo7Zt2xKgvOyDiJmbbp8DBw50iu3z6aefJk9PT7P+HDVqlBDelubK8ePHCQC1atVKkfmePXsIKL2Mk5buRMp+WbVqldm/S8T+lJC6xdhbQprnti6FJFrmxt7GAKWX+rxz547w3qL1p4S1uSJyfxLZzlzU/pSwlLno/Smxbt06q/sWYwYOHEgeHh7ytlle/l9cCqksiAhbt25Fnz59QERIT0+Xfx5//HFkZWXhxIkTNsfw9fVFVFQUJk6ciG3btmHZsmUoKSlBv3795JsgAcCECROQmJiI0aNH49y5c/j7778B/HNUPz8/HwAUl0T68ccfERsbi9jYWHmcxYsXa+qdkJCA/fv3y49L3qYkJibi+PHjZqfqiJg5UHr5Hb1erxgTKP3GaHp6upCZ9+rVC3Xq1MGxY8eQl5eHa9euYdOmTZgxYwYAyHeHL6+79Dqvvvoqtm3bpngdNzc3RY75+fkWz0KQLuMhrSv9aekIujSmiN5qEMHb+HFrTJo0CefOnQMAuLi4CONuLXNXV1fs27cPO3bswJw5cwD88+0FEbyNH5dYuHAhDAYD/P39ra4vgrulzB9++GEEBARgwIABGD58OL799lsAwLlz53D48GEhvI0fB6C4vF1oaKjcn9L+Mz4+XujMjZE6FPhnPymqd2X3Z2XMFRH7Uy1l9ScA5OXlCeetBhHztsSCBQvk/Yq0TYju/v3332P37t344IMPAJTuJ0X2/uKLL3Dnzh2L3yyWENU9OjoagYGBGDx4MIYMGYIvvvgCQOllb7Zs2SKkt9SfhYWFqF69Ol544QU888wz+PHHHwEAv/76KwBxMzcmOzsbu3btAiD+9unq6gq9Xo+RI0di8+bN8uUwNm7ciEuXLgnp3bp1a7Rr1w5nzpxBbm4url69iu+//x7jxo0DIEZ/3rlzBwDw0EMPYeTIkfJy0fvzwoUL+OWXXwBA4a0WETO3xIIFCwAAXbt2RUBAgPDeIvanrbkien/aylzk/rSWuTP054ULFzBx4sQyt0+pP3v16iVf9qncVMTRCUdQnjMW0tLSzL4hYPpjegMOY4qLi6lZs2Y0adIkxfLExETS6/X02muvKZZPnz6d9Hq9YvwZM2YQANq+fTsR/fNNbk9PTzPvunXrUr169TT3Dg4Olv9b8paQMp85cyYBoGPHjgmfeXFxMQUEBJCvr69Z5i4uLvTaa69p7m0t84SEBPL395cf8/DwoI8++ogAUEhISIVkLr2O9O1249epXr06PfDAA/J6FXnGgojeRGWfsaClt7G7qbex++LFiwkAzZ07Vxh3e77JTfTPzbN27NghZOZXrlwhLy8vevjhh2V3S2csOGPmc+fOFTJz4/2KJfeAgACnyVzqUNHniiP6szzexu6meYvWn8aU94yFpKQk4byJyj5jQeu81ZyxsGHDBtLpdDR69Gih3NVkLgGAXF1daenSpZp7W8o8KyuLQkJC6IEHHpDdLX3jUmt3ezMHQKNHj9bc21Lm0mNVqlSx6O7i4kLFxcWau6vJfPXq1U4zV8LDw8nLy0uxDCj9HGDw4MGae1vbJ16/fp2qV68uj+nq6krTpk2TxyfSLvObN2+Sn58fAaCUlBSL/y4R+/PmzZsUERFBVapUKXOeWztjQcTMjb2JSO5QZ/OWkOa7lv1pa66I3p/3mzmgbX/aylz0/pTca9WqZTFzY6T+NL0qTXn4n7jHgnT9/2HDhlk9cmN8bUZTfv31VyQkJGDJkiWK5Q0bNkTTpk3lb0dKzJ8/H6+++irOnj2LTz/9VHEPgkaNGgEAwsPDAfzzDWJjfHx8kJKSoqm3v78/VqxYgU8//VThbcrXX3+Nxo0bIzo6WrFcxMx//fVXZGZmmt1YGSi9flp8fDxeeuklzbxtZR4VFYV+/fph37592LhxIyIjI+Hl5YUpU6bIN38ub+bS6yQkJODcuXO4c+eO/DovvfQSYmJi5PXCwsKQkpJi9nzpLBFpfoeFhQFQXq9dIicnB+Hh4UJ6q0EEbwlL3rm5uXj99dcxfvx4vPXWW3j77beFcrcn8ypVqiAuLg5t2rTR3FtC8p45cyZq1KghXz/36tWr8jW5gdKbfhkMBqfLHAAyMjKE8JaQvKU/PT095WtgGiN9k0ME97Iylzr0zz//lJeJ6O2I/qwIbwnjvEXrT7WU1Z9Vq1aFXq8XzlsNIuZtTEFBAUaMGIEnnngCy5cvx6pVq5zG3ZSwsDDExcVh0KBBwnm///77KCoqQt26dXHs2DFcvXoV169flx/PzMxEUVGR02Xu7e3t8P5Ui3F/WkK6GaWI7qbExcXB398fWVlZCn/RvC9fvowbN27IfWNM7dq1ER8fL6Q3UHo/gp49e2L//v1Yv349GjZsiNDQULz33nua9mdWVhZ69uwpX4vc9D2WqP0peWdmZqJPnz5Yv369zfGtIWLmxuzbt0/u0J07dzqNtyla9mdZc0Xk/ixP5lr2Z1mZi9yfxu4HDx4sM3OpP3v37m1zPXv4nziwEBwcDF9fX9y7dw9du3a1+/lpaWkALJdTcXGxfCqgMYGBgejYsaN8U8b9+/ejZs2aaNKkCQCgefPm0Ol0VgsvODhYU29jjL2NKSwsxLVr1+TLlRgjYubSmJY+iDIYDCgpKRE+c71eL68r3bAsIiICQPkzl9DpdIqbvezevRsGg0ExZsuWLXHgwAFkZ2crbp555MgR+XEAaNasGXQ6nVwsxqSmpqJbt25CeqtBBG/jx41JSkrC33//jYEDB8oHqkRztyfzkpISZGVlCeFt/DhQmvWlS5dw6dIlADC7gdNHH32E2bNnC+Fu7zyviB6qCG/jx4HS/tTr9cjLyzO7sRVQenBe8tfa3VbmR44cwaVLlzBnzhzMnDlTXi6ityP6syK8jR83RZT+VEuNGjXg4eFhsT9TUlLQsmVLIb3VILL37du3cevWLTz00EPYtGmT2Y1LRXa3RHFxscP7Uy1JSUm4c+eOfAk+S/0ZGxuL5s2bC+dui7y8PIf3p1rCw8MRGhqK7OxsuSuNcXV1ha+vL6pUqSKcuzE3b97EgQMHEBsbK19WCBBz+xStP+8HNzc3PPLIIwAgX15Vq/4sKChAnz59kJiYiN69e2Pr1q1mY4nYn8be+/fvR1xc3H2/poiZSxQWFqJ///5o06YNNm3aJN9wVnRvS2jVn2rmiqj9Wd7MtepPNZmL2p+m7pGRkTbHNe5PW5eVtZsKO/ehkinvzZtjY2PJ3d2dzpw5Y/b8W7du2Xxt6TI/I0eOVCw/fvw4ubi4KG4Uac0bAL3//vuKx2rVqkUA6Pz58wpvnU5HEyZM0NSbiKh79+4WvYlKM/f19SUAdOnSJdld5MylMaUb3EhI60pjipy5NM/z8vLkG0S/8cYb8jrlcbeE9DphYWGUnZ0tLz98+DABoPfee4+I/sm8QYMG1K5dO8UY4eHh5Orqqni+lPn3338vrLeamzdr5U30z42+Tb1/+eUXcnFxIU9PTyooKJCXi+JuLfPc3Fx69tlnrZ4WKd14WrTMDx48SNu3b6fHHnuMgoODafv27fKlpwDQ008/TUVFRZq6W8s8KyuLhg0bpsjcYDDI7sePH9fUm8j6PH/yySdJp9NReHi4vOzcuXMEgNq0aSMvEy1zon/2LZMnT5Y7VPTt0xH9WR5vIutzhUis/jSmrMtnNGrUiHQ6HSUlJcnLpPU/++wzYb3V3LxZS29rl/04d+4ceXh4kF6vp4yMDHm5SO6WvIuLi2no0KEW+1On09Hw4cM197Z2c1jT/lyxYoWiPzMzMzV3t5R5fn4+PfPMM1bfs0iXORAtcyKiKVOmEPDPpeCIiG7fvi3v+yVEy5zon33LkiVLCAD9+OOPwm+ft27dIvz3UhYGg0FeDpTeAFm6QayIc4VIuT+/d+8ePfHEEwSApk6dKq/jKPeSkhLq27cvubm50a5du2x+PiRSf5p6E6n7bMvWzZtFzLxfv37k4uJCUVFRcoeK7i1af6qdKyL2p9rMRetPe7ZP0frTkntZGPdnRfI/ccYCUHpzzQMHDqBdu3YYM2YMIiMjkZGRgRMnTmD//v3IyMiw+tzo6Gh069YNa9euRXZ2Nrp3746bN29i6dKl8PLywtSpU+V1f/31V8yZMwfdu3dHtWrVcODAAQBAjx49MGXKFMW4rVu3xvXr19G5c2dMnjxZXu7l5YXp06dr6n348GHs27cPAMy8gdJvXdy9exft27dH/fr1nSLz6OhohIWF4ebNmxgwYIA8JlD6TUZpTBEzHzx4MBISEpCbm4v3338fq1evxuXLlwFAcaSxPO7S64SHhyMyMhLZ2dny6+zatQu+vr7yeu3atcNTTz2FN998E7du3cLZs2cBAFevXlVcMgAonec7d+5ETEwMxo4dK5+mFxERgR49egjrfefOHWRlZWHevHm4dOmSfKr1r7/+ih07dqBPnz6aeTdo0ADffPMNgNIbvUtcu3YNffv2hU6ng7e3NzZv3qx4PelbUyJmfvHiRWzZsgXu7u5YunQpXFxccOzYMQCAv7+/vE2Ilrn0DehvvvkGly9fRr9+/RQ3QWrSpIl8urVomZ84cULOfNmyZcjPz8f27dsBlG63rVu3FjJzoPSGcLt27UJaWhoWLlwIAPj4448BQP5WnYiZG7Nx40arHSqatyP6szzetuaKaP0JAJ988gkyMzNx48YNedm8efMAAC+++KJ8I/gWLVrg0qVLeOyxxzBlyhT5xnHVq1fHc889J6x3bm6u3J/Sfhwo7c9169Zh+PDhmnpfvXpVdpe8c3Jy8Pjjj6OwsBABAQHyTWElkpOT5f8WLfPc3Fxs3rwZnp6eWLJkCXx8fHDmzBkApXNcuhSiaJlLPWPcn9J6QGl/SnNKtMxTU1PlzKXu2bt3LwCgfv36ePLJJzX3tpQ5ALz55ptYuXIlbt26hdmzZ8Pf3x/Lly8HAHTp0kUeT7TMjYmLi0N4eDg6depk9rqieQcHB6Nhw4a4ePEiunTpggEDBiAnJwdA6Rm5b775pube1ubKlClTcOjQIeTk5ODjjz/G119/jaNHjwKA4v+Jo9xfeeUVfPfdd+jTpw8yMjLky0h+9dVXAEovPSIhUn+aen/11VcKd2Pva9eu4fTp08jKypL7U5pTp06dEjbznJwc/PDDDzAYDBg+fLiiQ0+fPo1Dhw7hoYceEs5btP5UO1dE7E+1mYvWn/Zsn6L1pyV3Y4zdJWz1Z7mo0MMUlUh5z1ggKr15ycSJE6lWrVqk1+spNDSUunTpQitXrizz9fPy8mjOnDkUGRlJXl5e5O/vT71796aTJ08q1rt06RJ1796dgoKCyMPDgwICAggAFRYWWvQOCwujrl27ko+Pj3wGgOmNf7XwbtKkCbVv395q5l27diUA9PHHH8vLnCHzYcOGUUBAgGJMADRu3DjNvW1lvmjRIvkGOIGBgdS3b186efJkhWe+aNEiatKkCXl6eipexxL5+fn06quvUmhoKLm4uBAA2rNnj9l6I0eOpNDQUOrQoQN5enrKN6g2/qaoiN4PP/ywfOTc9Mf4jBQtvD08POSbqRljfNNgSz8xMTGK9UXK/Pbt29SoUSNyc3MjHx8fcnd3p4YNGxIAmjZtmube1jKXMO4hSzdv1tLdWuaXL1+mOnXqkKurK3l6epK3tzdFR0cTAJo5c6bm3mVl3rt3b/L09JT788knnxQ+c6LSuSL9u6QOdQZvR/RnZcwVEftTOgPO0s+VK1fk9UaOHEnh4eHUvXt38vb2lt/fvPLKK0J7P/7446p6SCRv45seWvoxvVmeSO6FhYXUtGlT0uv15OfnR3q9Xn7elClThPWWMO5PSzefFNH9zp07FBERQW5ubuTt7U0eHh4UFRVFAOitt94S1ltiwIAB5O3tTX5+fuTl5SV/Y13kzIn+2ScCoJdffpmItO1Ptd7Dhw+nqlWrUsuWLalKlSryjUFHjBghtPeaNWsoMDCQdDod+fr6UpcuXeinn37SLPOYmBib+2ljROpPe7xt/S5n+nmXSO5ldaijf3dW6y1af9ozV4jE6k+17qL1p72Zi9Sf9rpfuHBB0Z8ViY7IwgX/GIZhGIZhGIZhGIZhGIZhGIZhLOCitQDDMAzDMAzDMAzDMAzDMAzDMM4DH1hgGIZhGIZhGIZhGIZhGIZhGEY1fGCBYRiGYRiGYRiGYRiGYRiGYRjV8IEFhmEYhmEYhmEYhmEYhmEYhmFUwwcWGIZhGIZhGIZhGIZhGIZhGIZRDR9YYBiGYRiGYRiGYRiGYRiGYRhGNW5aC4iGTqez+hgROdDEPpzVG3Bed2f1BpzXnb0dj7O6O6s34Lzu7O14nNXdWb0B53Vnb8fjrO7O6g04rzt7Ox5ndXdWb8B53Z3VG3Bed/Z2PM7q7qzegHO7m8JnLDAMwzAMwzAMwzAMwzAMwzAMoxo+sMAwDMMwDMMwDMMwDMMwDMMwjGr4wALDMAzDMAzDMAzDMAzDMAzDMKrhAwsMwzAMwzAMwzAMwzAMwzAMw6iGDywwDMMwDMMwDMMwDMMwDMMwDKMaHTnb7aYZhmEYhmEYhmEYhmEYhmEYhtEMPmOBYRiGYRiGYRiGYRiGYRiGYRjV8IEFhmEYhmEYhmEYhmEYhmEYhmFUwwcWGIZhGIZhGIZhGIZhGIZhGIZRDR9YYBiGYRiGYRiGYRiGYRiGYRhGNXxggWEYhmEYhmEYhmEYhmEYhmEY1fCBBYZhGIZhGIZhGIZhGIZhGIZhVMMHFhiGYRiGYRiGYRiGYRiGYRiGUQ0fWGAYhmEYhmEYhmEYhmEYhmEYRjV8YIFhGIZhGIZhGIZhGIZhGIZhGNXwgQWGYRiGYRiGYRiGYRiGYRiGYVTDBxYYhmEYhmEYhmEYhmEYhmEYhlENH1hgGIZhGIZhGIZhGIZhGIZhGEY1fGCBYRiGYRiGYRiGYRiGYRiGYRjV/L84sBAbG4u6desqlul0OsyePVsTH7U4qzfgvO7O6g04rzt7Ox5ndXdWb8B53dnb8Tiru7N6A87r7qzegPO6s7fjcVZ3Z/UGnNedvR2Ps7o7qzfgvO7s7Xic1d1ZvQHndq9MhD2woNPpVP38/PPPDvEpLi7GO++8g4iICHh4eCAiIgLz5s1DSUlJubzz8vLQvn17BAQEoFq1agCAxMREh3v//vvvdrmfP38eKSkp8PDwQI0aNfDyyy9XmLO97vZmXlxcjB49eqBKlSqoWrUqAODu3bsO9z579qxq988++wyHDx/GzZs3odfrodPpKsz3ftzVev/000+4dOkSbt26hVq1asHHxwfNmjUDALMxRfL++eefkZiYiNTUVISEhMDDwwP16tUDAGRmZjrc2565YrxPLC4uRmRkZKXMl8rI/LfffsO1a9cUywHgk08+cbi3vZkTEXJyctCyZUt4eXnJ+/PU1FSHu9vjvXbtWouZv/POO+jWrZuw3oA4/WnvXHHm/iwsLETHjh3h7e2N0NBQAEBRUZHDve1xf++99xAfH48bN27A1dXV7JcBR7ur9d6zZw8uXLiAtLQ0hIWFwdfXF61atQIAGAwGh3vb4/78889j165dSE5OhqenJxo2bIipU6dWmLO97vfTn0Bp31evXh0AcO7cOaG99+zZY3Ff/tVXXznc2153g8GArKwsNGnSBJ6enggJCQEAZGdnO9xdrfeGDRts9ueYMWMc6m2P+08//YQ///wTN27cQJUqVRASEoKePXtWiO/9uNs7VzIzMxVjAtrsE521P3/++WfuTwd725M596fjvUXqT3vmCvdnxXjbk7lo/WnL/fDhw/c15v3iViGjVALr1q1T/P3LL7/Evn37zJY3bdoUn3/+eYWWhCWGDRuGzZs3Y9SoUWjTpg0OHz6Mt99+G0lJSVi5cqW83oMPPojExES0bdsWtWvXxs8//4y//voLHh4emDVrFmrVqiV7t2zZEmvXrkXbtm2xcOFCFBQU4KWXXsL69esxaNAgDBgwwGHeixYtgr+/v+ydmZmJHTt2oKioCAsWLJC9AWDLli04evQo+vfvj+7du+PcuXNYunRpuV3v1/2VV17BDz/8gAYNGiAwMBDx8fH4888/AQDPPfccOnfuDKA081mzZmHnzp24dOkSFixYgNzcXMyYMQPr1q3D/Pnz4e7u7jDva9euoXnz5rJ3UVERdu7ciczMTIU3APzxxx/466+/0Lx5c9y9e7dCPzy7H3e1mdetWxfx8fFo27Yt+vbti+rVq+PQoUM4e/YsvvrqK8ydO1cuEpG8mzZtiubNm6N+/fpo2bIlAgMDceXKFcybNw8rV67Ea6+9hvDwcId52zNXjPeJS5cuRVJSUrk9y+NuT+YdOnRAcnIyVq1aJT9/+PDhFfYBtz3e9mZORMjKykK/fv0wadIk3L17F1OnTq3Qg5aVkfmaNWtARNDr9fLzhw8fDgDo3r27sN4i9ac9c0W0/jR+T5WRkYGXXnoJBoMBNWrUwMKFC+XHmjZtiokTJ2LDhg3Iy8vDkiVLcP36dcyfPx+bNm3CggULHOpt7J6RkYFp06ahpKQEBoPB7H3ijh07kJycjOjoaFy/fr1CPMvjrjZzT09PHDlyBJ07d0aPHj3g5+eHvXv34o8//sC3336LOXPmONTb2L2szNevX49+/fqhcePGCAwMxPnz5/H5558DqNgP0ipjnhv/TjFz5kzk5eVVmG9lejdq1Ahubm6K5cOHD8fDDz/scG9j97LmSoMGDZCSkoLCwkL06NEDLVq0wJ07d/Dqq6+ioKDA4e5qM2/btq1Q/WnsXlbmmzZtwuHDhzF06FB06tQJmZmZWLFiBQAgJSWlQrztcbdnnufn5yMrKwuDBg2Sx7xy5Qp27drl8H3i9OnTsWDBAnTv3h0RERH47bffkJCQgPHjx6NFixbw9fWVvUXrTwCyNwDZfdmyZbI3IF5/qs1cxP4E1GUuWn/aM89F6k97vEXrT0DdXBGtP9VmLmJ/Sq9bVuai9afE5MmT8eCDDyqWNWjQoFxj2g05CRMnTiR7dAHQrFmzKuS1jx49SgDo7bffVix/5ZVXSKfT0alTp+Rl8fHxVFhYKP9d8vbw8KBnn31W8fyGDRvSgw8+SAaDQeGt1+upb9++mnoTET377LMEQOF948YNcnNzo+HDhyvWXbp0KQGgIUOGlNvbXndTpMwfeOABaty4seKxF154gby8vOjatWvyMgAEgFasWKGpNxHRhAkTCICZd2pqKuXl5RGRclvQap6bYi3zwsJCio+PN1tfynzfvn1CeltD8n733Xc19SayPlck0tLSyN/fn+bMmSN7izxXiIhGjhxJPj4+imWieBNZz3zjxo0EgLZt2yak+/3O8+TkZGG9RepPS1iaK6L359NPP001atQgABQVFWX2eM+ePSksLIyysrLkZdJc2bt3r6benTt3pvDwcIvvE1NSUqioqIiIiJ544gmqU6eO7K719mkr89u3b1NCQoLZc6TML168qKm3rcwtsWXLFgJAAwcOLLc3UeXNc4kzZ86Qm5ub3KFPPfWU0N4xMTFmy0WZ47bmyqJFi0iv19ORI0eEdFczV4wBQO7u7pSfn6+pt7XMi4uLycvLiwYNGqRYfvnyZQJAbdu2Lbd3ed2tZW5tTGmfWFYvV7T3gQMHCABt3ryZiGx/ViFSf5p623IXrT/VZi5af9qTuSW07E975rmECP1pj7dI/WnPXBGtP+9nrph6a9GfajMXsT8tuZd3zPtF2Esh2YOl61xZIiUlBaNGjZIvbRIVFYXVq1eX+byDBw8CAIYMGaJYPmTIEBARNm7cKC/r0KGDxW+9R0VF4fz584plycnJSEhIMPvGtru7O7y8vDT3DggIAACF96FDh1BSUoIbN24oMpdeIyEhQTGGI9ytUatWLbPL1qxZswY6nQ61a9dWLK9atSo2bdqkubc0F0y9Q0JC8MILLwgzz61hmrm7uztWrlxp1dt4bonkDdjerxivK9pckdzr16+Pxo0bY9iwYVbHEC3z3377DXl5ebh3757NUzhFy3zJkiUICgqSv2Vn6ywF0TI3neeFhYUAgDp16qBmzZrCeovUn5awNFdE7s9ff/0VW7ZswSOPPGJxzOzsbOzZswd3796Fn5+f4jG9Xq9Zf0reH374odVxw8PDMWbMGOH6s6zMg4KC8N577wnXn2oyB8z3LdJ/m36LTqTMjb2nTJmC/v37W11XNO8LFy4gMTERJSUlyM3NtbqeSHPFYDDgo48+Qo0aNTB48GCUlJTY/IaraJmbzvGbN28CKP0GrKenp6be1jIvLi5Gfn4+EhISFO7SJUuMvz2qlbu1zKUxjc9qNcZ4TEd3f05OjtWrJ4jan5K3rctgiNqfkru1zEXtT8m7rEuPiNifkrutq4SI2J9qvEXsT8nb2lwRuT8ldzVzRUKE/pS8rWUucn+W5V4Rv4+XhbCXQqpo0tLS0L59e+h0OkyaNAnBwcH4/vvvMXr0aGRnZ9u8dp30QYvxhxUA4O3tDQA4fvy4qtePiopSLAsNDcXVq1exdOlS9OnTRy6LwsJCTJkyRXNvIgJQWs6mY7q5KaeONKa0U9DC/e7du/IpsgDw/fff4+mnn5YfT0lJQUFBAQIDA82eW6NGDZw8eVJz7z/++AMA0KVLF6uvYQvRMi8LaW6J7P3333/j3r17iksKSf9/RJ0r6enpyM3NxYcffmj1UlOiZk5E8PPzQ15enrytGp/6K1rm2dnZOHr0KBo3boybN2/C398fubm58j05jBE1c2N2794NAGjRooXQ3iL2Z1lzRdT+vHfvHl588UU8//zzZm4SZ86cARHBw8PD7LHQ0FBN+tPYu3nz5lbHVYtomZeFFv1pb+YGgwGpqam4ePEi3njjDQBQ/DImauZ5eXn4z3/+g/Pnz+Pq1atmj4vqXVxcDB8fHxQVFcnXWb53757m3tbmyrlz53Djxg20atUKFy9elN0trS9q5sZs2LABgHb9qSZzLy8vtGvXDsePH0dAQACSkpKQmZmJuXPnAgCio6M1d7eWuTSmtfe10piO7v7nnnsOubm5stexY8fQpk0b+XER+9PY29XVVd5f3C+iZV4WWv3+aU/mIvWnsXtZmYvUn/Z4i9Sfxt7W5oqo/Wnsbs/2qXV/Gntby1zU/jR1f+SRR/Dee+8pMq+Iz7PLpNznPDgIW6fSjBw5Uj41TwImpwCNHj2awsLCKD09XbHekCFDyN/fX77MjCW2bt1KAGjdunWK5cuXLycA1KxZszK9AdCqVasUjz399NPk6ekpPy79jBo1SnNvIqKuXbuaeR8/fpwAUKtWrRSZ79mzR74MhVbu48aNU+Q4aNAgysjIkB///fffCQAFBQUpngeAOnToQACooKBAc28ACm8JaZ7buhSS1u6mmRt7G4P/nup2584d4b09PDwU6/bo0UNeR2tvS3PFYDBQUFCQfEmhK1euyOuKPleaNWtGfn5+tHHjRlq/fj2NHDmSAFCtWrWouLhYCG/TzE+cOEFA6eXuXFxcaNmyZRQXF0dt27YlQHkpOa3d1WyfAwcOJAD0+uuvC+0tYn+WNVdE7c9PPvmE/P396datW3K/mJ4SvnnzZgJAoaGhiuUAKDIyUl6ulTcR2bwsjzTPbV3KQbTMjb0lCgsLCQAFBARosk+0J/PBgwcrtoWaNWs6RebDhg0jV1dXevPNN4non9PMjS/lIKJ3gwYNyN/fn7Zu3Upffvkl9e3bV94+tfYmsjxXtm3bJvenm5sbrVmzhtasWUMNGzYkADR+/HjN3e3ZPqOjowkAzZw5U3NvIuvb58WLF6lq1aqK7TMiIkL47VMa09LvccZjOso7Pj6eBg4cSKtWraJvv/2W2rdvTwDI09OTTpw4Ia8nWn+aer/77rvy7zrG3hIi9afazI29JbTsT3szF6k/7clcpP60x1uk/lQ7V0Tsz/Jsn1r2pz3bp2j9acm9WrVqZpmX93NhNfxPHFgwGAwUEBBAY8eOpdu3byt+1qxZQwDot99+s/ra+fn5VKdOHQoJCaGtW7fS1atXaePGjVStWjVyc3Oj+vXrW33uM888QwDooYceopKSErPHfH19aeTIkbR582ZavXo1ASAfHx+6ePGipt7nz58nvV5PAMy827VrR25ublStWjW6cuUK7d69m+rUqUMASKfTaZb5+fPnad++fdSlSxcCQP3796fU1FT58V9//ZUAUHBwsOJ5AOjRRx+VPwTSynvt2rVyjsbeEmUdWBAxc2Nvifnz5xMA6tWrl1N4//TTT7R792764IMPCAB16dJFc29bc2X16tXk6upKNWvWJCLLBxZEz9wYyX39+vVCZi7tV0x/aczJySGg9KCIs2SelZUlf1gv+lwRsT/VbJ+i9Wd6ejpVrVqV3n//fSIiqx/ofPnllwSAwsLCFMsBUIsWLcjf319Tb6LyHVgQMXNjb4kxY8YQAHrmmWc09y4r8+HDh1NISAjt2LGD5syZQy1btnSKzB944AFydXWlnJwcIjL/YERUb1v9eejQISHnirRfcXFxkd+zEBFdu3aNAFDz5s2dJvM///xT0/da9myfqampFBERQb6+vrRt2zZatmwZ1a5dmwDQtGnTNHe3lnl+fj75+PiQi4uLYkypP+vXr6/p786St5eXFz3++OPyctH60xLDhg0jAApvCZH60xRrmRt7S2jZn5awlblI/WmKrcxF6k97vEXqT0tYmisi9qcpajPXuj8tYW37FK0/LXHx4kWzzMs7phr+Jw4spKWlKY4qWfoxvemmKQkJCRQZGSmv7+HhQR999BFVr16dHnjgAYvPuXnzJvn5+REASklJMXs8PDycvLy8zLw9PT1p8ODBmnpHRERQlSpVLGZ+/fp1ql69ujymq6srTZs2TR6fSLvMif6ZK926dVPc3FPNGQtJSUmaeRu7m96UlKjsAwsiZm7sTUS0YcMG0ul0TuctIc33pUuXaupt7G7snZWVRSEhIfTAAw/I7pYOLDhb5gBo9OjRQmYu7VeqVKli0d3FxYWKi4udInPpw3lnmCui9qepu6m3aP05fvx4atCgARUWFiq87+eMBS29icp3YEHEzI29iYgWL16s6fZ5v5lLxMfHEwAaOnSo5u7WMr9y5Qq5urpStWrV5GWmH4yI6G0pb6J/+nPu3LlCzhXj/Yol94CAACJyjsxnzpzpFNtncXExNWvWjJo0aaLIPDExkYDS34e0dreV+ZNPPil/8U0aEwB5e3vTAw88IMR7liFDhpC7u7v8xTzR+tOWu7G3hEj9ac3bNHNjbyLt+9OWu63MJbTsT2veppmL1p9qvYnE6k9b7tb2K6L0pzXvsjLXuj9tuRt7i9if1rCUeXnHLIv/iXssSDcOGTZsGEaOHGlxHePreVkiKioKCQkJOHfuHO7cuYPIyEh4eXnhpZdeQkxMjNn6WVlZ6Nmzp3w9q/DwcMXjly9fxo0bN1CtWjWz59auXRvx8fGaemdmZqJPnz5Yv3692To1atRAz549sX//fqxfvx4NGzZEaGgo3nvvPfnfo4W7KYMGDcK4ceOQmJiIxo0bIywsDIDyenkSOTk5qFq1qnzTFS29AeD333+XvdUiYubG7Nu3DyNGjMATTzyBnTt3Oo23KWFhYYiLi8OgQYM09waUc+X9999HUVER6tati2PHjuHq1au4fv26vG5mZiaKioqcLnNvb29kZGQI4Q0oM5f27cY3mjJGupmzCO5lZR4XFwd/f3/53gaSv2jeovanJUz35SL158WLF7Fy5Up8+OGHuHHjBgDIN00vLi7G1atX4efnh6pVq5bZn+Hh4Zp6G7sZe6tFxMyN+eKLL/D6669j/PjxWL58uRDegH2Zd+jQAQBw+vRpzd2tZT5z5kx4e3vD09NTvjZ0amoqgNJ7qFy9ehXu7u7CeZeFI/vTnrli3J/03/u6GZOfnw9AzLliytdff43GjRvjzz//lJeJmPmvv/6KhIQEdOvWDYmJifK6DRs2BAAkJydr7m4r84CAAISHh2PXrl3ymNWqVUNeXh4aNWokRPfXqlULRUVF8s2aRerPsjD2VosI7qaZG6N1f5aFmsy16k9bmGYuUn/a410WIv3+aewtWn/aoqzMtezPsjD2Fq0/bWEp84rIwxb/EwcWgoOD4evri3v37qFr1673PY5Op1PcgHn37t0wGAxmYxYUFKBPnz5ITExE7969sXXrVrOx0tLSAMDijsBgMKCkpERT7/379yMuLs7muG5ubnjkkUcAlN5ABgAiIiIAOD5zS0g7VOlDsho1asDDw0M+2GNMSkoKWrZsKYS3hPGHe2oQwd00c4nCwkL0798fbdq0waZNm+QbxYjubYni4mJkZWUJ4S0heSclJeHOnTv49ttvAcDsBsIfffQRYmNj0bx5c83d7ck8Ly8PwcHBQmYeHh6O0NBQZGdnw8fHx2w9V1dX+Pr6okqVKpq728r85s2bOHDgAGJjY7F69Wp5uQiZm3qL2J+2sJS3CP2ZkpICg8GAyZMnY/LkyYrnJiYmol69epgyZQo+/PBDNGvWDDqdzmJ/pqamolu3bkJ4A1B4q0UEd9PMJfLy8vD8889jwIAB+PTTTxUfjIjgDdiXuTSHRHA3zTwpKQk5OTnIyckx68/du3ejXr16SE9PF867LBzZn/bMlebNm0Ov1yMvL8/shoIA5E4Vwd1W5keOHMGlS5cwZ84czJw5U14ugjegzNxWfwL/fCAigrutzI3HlOjatasQ3X/58mV4enqiSpUqACBUf5aFsbdaRHA3zVxChP4sC3syd3R/2sI0c5H60x7vshDp909jb9H60xa2Mte6P8vC2Fu0/rSFtcwr4vdaq5T7nAcHUd6bN8fGxpK7uzudOXPG7PnSTa7sIS8vj1q3bk1hYWGUnZ0tLy8pKaG+ffuSm5sb7dq1y6r3rVu35FNQjC+TAJTewFG6QaxW3kTqM7937x498cQTBICmTp0qr+Mo97S0NMV6knfr1q3Jy8tLvs4fEVGjRo1Ip9NRUlKSvAz/PR3os88+09SbiOiFF14gAGbeROpu3ixi5v369SMXFxeKioqSb2QqundxcTENHTrU4n5Fp9PR8OHDNfUmsjxXjh8/Ttu3b6fHHnuMgoODafv27bRixQp5jj/99NOUmZmpqbu1zPPz8+mZZ56xeiqqdMqgaJkTEU2ZMoUAUEhIiLzs9u3bBIAaNGggLxMtc6J/9itLliwhAPTjjz8Kv32K1p/3uy8n0rY/b9++Tdu3b1f89OzZkwBQ7dq1afv27XT69Gl5jPDwcHJ1dVX826Xt8/vvv9fUe/v27fLN1Ey9idTdfFLEzHv06EEA6LHHHqOCggKhvK1lnpubS3fv3jV7b75lyxYCSu9ppbW7tcwPHjyo6M/t27fT3LlzCf89xX379u1UVFQknHdWVhYNGzZMkbfBYJC3z+PHjxOReHOFqPTSNjqdjsLDw+Vl586dIwDUpk0beZlomRP9s1+ZPHkyAaBLly4Jv30eO3aMAFD9+vUV8+X48eMEgKKjozV3V5O58ZhA6eUopTEd1f2mY0nvWfR6PfXt21fxmCj9aW2sp59+mgCYeROJ05+WxrKVuSj9aW0sS5mL1p+WxrKWuUj9aY+3SP1pbSxr26dI/WlpLFvbpyj9aW0sS5mL1p/Wxvrjjz8sZq52zPvlf+KMBQBYuHAhDhw4gHbt2mHMmDGIjIxERkYGTpw4gf379yMjI8Pm8wcPHozw8HBERkYiOzsbq1evxuXLl7Fr1y74+vrK673yyiv47rvv0KdPH2RkZMin9Hz11VcASk+JAUqPZDVs2BAXL15Ely5dMGDAAOTk5AAASkpK8Oabb2rq/dVXXyncJW8AmDJlCg4dOoScnBx8/PHH+Prrr3H06FEAgL+/v8MzHzduHLKzs/Hoo4+iRo0aOHbsGADgxIkT+OCDDxRH6lq0aIFLly7hsccew5QpU5CbmwsAqF69Op577jlNvVNTU+VLT82bN0/hfe3aNZw+fRpZWVnyv2/evHkAgFOnTgmbeU5ODn744QcYDAYMHz4cu3btksc4ffo0Dh06hIceekg479zcXGzevBmenp5YsmQJfHx8cObMGQCAh4cH3n77bU3ztjZXWrdujdatW+Obb77B5cuX0a9fP/l0VABo0qSJvI2Klnlqaqqc+ccffwwA2Lt3LwCgfv36ePLJJ4XMHADefPNNrFy5Erdu3cLs2bPh7+8vfyuqS5cu8nqiZW5MXFwcwsPD0alTJ7PHRPMWrT/tmSsi9WdQUBD69euneN7+/fsBAL6+vmaPtW7dGjt37kRMTAzGjh0rX2YtIiICPXr00NQbACZOnAgAZo+dPn1a7s9Lly4hKytL7k/j065Fy/zatWv48ccfodPpMGjQIGzevNns39SiRQvhMr948SK6du2KoKAg5OTk4NNPP8WxY8fk98Ht2rUTNvOOHTuidu3acn8CpZdeAUrPepWWieZ94sQJbNmyBe7u7li2bBny8/Oxfft2AP+8L9DSG7C+fS5YsAC7du1CWloaFi5cCADyewDprC4t3W3tEyU2btyI9u3bo379+maPiZZ5dHQ0unXrhn379sHb2xvLly/HzZs3sXTpUgBA+/btNXe3lfnPP/+MjIwMrFy5Uh4TAPr37y+P6ajuf/rpp+Hl5YUOHTqgevXq+O233wCUXr5TmssSovSnJe9z587JV1cw9RapP+3JXKT+tCdz0frTnsxF6k97vEXqT0vetrZPkfrTnsyN0bo/LXlby1y0/rTmvnLlSouZqx3zvin3oQkHUd4zFohKv1U4ceJEqlWrFun1egoNDaUuXbrQypUry3z9RYsWUZMmTcjT05MCAwOpb9++dPLkSbP1YmJi5COcln6MGT58OFWtWpVatmxJVapUkW+WPGLECKG916xZQ4GBgaTT6cjX15e6dOlCP/30k2aZr1+/nrp27UohISHk5uYm38jr22+/NVt35MiRFB4eTt27dydvb28KCAggAPTKK69o7h0YGEg1a9a0OM+lmx9Z+jGd+yJlbnzjYEs/I0eOFNK7sLCQmjZtSnq9nvz8/Eiv11OdOnUIAE2ZMkWxrmhzhUi5T7R082Yt3a1lfufOHYqIiCA3Nzfy9vYmDw8PioqKIgD01ltvae5dVuYDBgwgb29v8vPzIy8vL+rcubPwmRP9s08EQC+//DIRadef9niL1J/2zBXR+tOUsm5UGhoaSh06dCBPT08KDg4mAPTGG29o7k1k/UbCa9assdpBpjcrEylzW71vOl9Eyvz27ds0duxY8vPzI51OR+7u7tSwYUOaOnWq08xz4/dVpjefFNH78uXLVKdOHXJ1dSVPT0/y9vam6OhoAkAzZ87U3JvI9o2+e/fuTZ6enuTj40O+vr705JNPOs1cqV69OgGgjz/+mIi0609LWMs8Ly+PWrZsSXq9nry8vMjf35969+4tjLutzKOjo8nNzU0xplbeH330EbVt25aqVq0qv3cFQBcvXjRbV6T+NPUOCwujRo0aOUV/qs1ctP5Um7mI/WnvPBelP9V6i9af9myfRGL1p71zRZT+tCdz0frTkvuwYcMsZl6e9xNq0BFZuUgUwzAMwzAMwzAMwzAMwzAMwzCMCS5aCzAMwzAMwzAMwzAMwzAMwzAM4zzwgQWGYRiGYRiGYRiGYRiGYRiGYVTDBxYYhmEYhmEYhmEYhmEYhmEYhlENH1hgGIZhGIZhGIZhGIZhGIZhGEY1fGCBYRiGYRiGYRiGYRiGYRiGYRjV8IEFhmEYhmEYhmEYhmEYhmEYhmFUwwcWGIZhGIZhGIZhGIZhGIZhGIZRjZvWAqKh0+msPkZEDjSxD2f1BpzX/YqrK6bXrIl5SUmoD+AvAJ0AXIfY3oDzZs7ejsdZ3Z3VG3Bed/Z2PM7q7qzegPO6s7fjcVZ3Z/UGnNedvR2Ps7o7qzfgvO7O6g04rzt7Ox5ndXdWb8C53U3hAwsMc5/UMxiwPikJgPKgAsMwDMMwDMMwDMMwDMMwzP9n+FJIDFMBDAcfVGAYhmEYhmEYhmEYhmEY5n8DPrDAMBXAOgA1tZZgGIZhGIZhGIZhGIZhGIZxAHxggWHuk78AdPjvn/UB/Aw+uMAwDMMwDMMwDMMwDMMwzP9/+MACw9wnnQAc+u+fxgcXamhmxDAMwzAMwzAMwzAMwzAMU/noyNluN80wIpKcDHTqBFSvDuzZA/j7a23EMAzDMAzDMAzDMAzDMAxTKfCBBYZhGIZhGIZhGIZhGIZhGIZhVMOXQmIYhmEYhmEYhmEYhmEYhmEYRjV8YIFhGIZhGIZhGIZhGIZhGIZhGNXwgQWGYRiGYRiGYRiGYRiGYRiGYVTDBxYYhmEYhmEYhmEYhmEYhmEYhlENH1hgGIZhGIZhGIZhGIZhGIZhGEY1fGCBYRiGYRiGYRiGYRiGYRiGYRjV8IEFhmEYhmEYhmEYhmEYhmEYhmFUwwcWGIZhGIZhGIZhGIZhGIZhGIZRDR9YYBiGYRiGYRiGYRiGYRiGYRhGNXxggWEYhmEYhmEYhmEYhmEYhmEY1fCBBYZhGIZhGIZhGIZhGIZhGIZhVMMHFhiGYRiGYRiGYRiGYRiGYRiGUc3/iwMLsbGxqFu3rmKZTqfD7NmzNfFRi7N6A87r7qzegPO6O6s34Lzu7O14nNWdvR2Ps7o7qzfgvO7O6g04rzt7Ox5ndXdWb8B53dnb8Tiru7N6A87rzt6Ox1ndndUbcG73ykTYAws6nU7Vz88//+wQn+LiYrzzzjuIiIiAh4cHIiIiMG/ePJSUlJTLu7CwEB07doS3tzdCQ0MBAEVFRQ73tsf9vffeQ3x8PG7cuAFXV1ezDcvR7mq99+zZgwsXLiAtLQ1hYWHw9fVFq1atAAAGg8Hh3va4P//889i1axeSk5Ph6emJhg0bYurUqRXmbK/7/W6fmZmZqF69OgDg3LlzDve2x71ly5ZYu3Ytrl27plhe0VRm5gsWLECTJk3g6ekJAIiLi8P169eF9N6wYYPVvN955x2MGTPGod72uP/000/4888/cePGDVSpUgUhISHo2bNnhfjej7s9c8VgMCAzM1MxJqDNPtFZ+zM2Npb708He9mTO/Vkx3vZkzv3pWG/R+tOeucL9WTHe9rrfunULqampcn9Onjy5wpztdbfH+8aNG/j777/RrFmzSuvQ/+/9aY8792fFeNvjzv3pWG/R+tMed+7PivG2112k/gSA48ePo0ePHvDz84Ovry+6d++OP/74w2y9H374AaNHj660/nSr0NEqkHXr1in+/uWXX2Lfvn1my5s2bYrPP/+8QiehJYYNG4bNmzdj1KhRaNOmDQ4fPoy3334bSUlJWLlypcL7zJkz+OCDD1C3bl24uroiMTERvXv3hsFgwNChQ2XviRMnYsOGDcjLy8OSJUtw/fp1zJ8/H5s2bcKCBQsc6g0Ar732muzdrl07nDx5EufPn0evXr1kbwDYsWMHkpOTER0dXWElUR53tZl7enriyJEj6Ny5s7zx7d27F3/88Qe+/fZbzJkzx6HegPrM169fj379+qFx48YIDAzE+fPn8fnnnwOo2A/SKmOeG2+fM2fORF5eXoX52usNqM982bJlqFGjBubOnQu9Xi8vHz58uCbu9mS+bNky9OnTB/Pnz8eYMWPQokULjB49Gu7u7sjKykLNmjWF827bti3WrFkDIrKYd/fu3cvtbI83oH6ubNq0CYcPH8bQoUPRqVMnZGZmYsWKFQCAlJSUCvG2x92euZKfn4+srCwMGjRIHvPKlSvYtWuXw/eJM2fOxK1bt+S///bbb0hISIC7uzuCgoKwaNEi2Vuk/hw3bhy8vLwUz5Xcw8PDZW9AvP5Um7lo/WlP5qL1pz3zXKT+tCdz0frTnsxF6k+13qL1pz1zRbT+tGeuiNSfycnJ8Pb2hpeXF7p06QIfHx/s3bsXN27cQKtWrfDyyy/L6967dw8//fQTmjRpgvHjx+P69et4//33K8T3ftw//PBDTJ8+XXY/c+YMzp8/DwAK96ZNmyI0NBTFxcXw9/dHeHh4hTtXhrdo/WnPXBGtP+2ZKyL1pz2Zi9af9mQuUn+q9RatP+2ZK6L1pz1zRaT+PHHiBPR6PapWrYrOnTuDiPDNN9+goKAAixcvRlhYmLyuaP154sQJdOzYEbVq1cKsWbNgMBiwbNkyxMTE4OjRo2jcuLG87tdff42NGzeidevWldOf5CRMnDiR7NEFQLNmzaqQ1z569CgBoLffflux/JVXXiGdTkenTp2Sl2VlZVFISAj179+f7t27Z9O7Z8+eFBYWRllZWQpvALR3715NvYmsZ56SkkJFRUVERPTEE09QnTp1ZHeRM799+zYlJCSYLZcyv3jxoqbeRPbN8y1bthAAGjhwYLm9y+uuxvvMmTPk5uZGc+bMIQD01FNPae5NZD3zmJgYioqKMlsu+jwnIlq0aBHp9Xo6cuSIU3lbAgC5u7tTfn6+pt5EludKcXExeXl50aBBgxTLL1++TACobdu25fYur7u1zK2NKe0Tjcd0hLcpkjcAmj9/vuIxkfrTEgMGDLDoLVp/mmItc9H60xLWMreElv1piq15LiFCf1rCWuai9acptjIXqT/t8baEVv1pCUtzRcT+NMVa5qL15/z58wmAYj9t7J6RkSEvt9Sfn3/+OQGgYcOGldu7vO6S94gRI8zcLXWoVtunWm/R+tOeuWIJLfvTnrkiIUJ/2pO5aP1pT+Yi9ef9zBVjtOpPtXNFxP5Um7lo/dmrVy8KDAyk9PR0eVlsbCwBoAEDBiieL1p/WnK/ceMGValSxczd2u+gFYWwl0KyB0vXubJESkoKRo0ahZCQEHh4eCAqKgqrV68u83kHDx4EAAwZMkSxfMiQISAibNy4UV729ddfIy0tDfPnz4eLiwuKi4stjpmdnY09e/bg7t278PPzUzym1+uxadMmTb3v3r0LIrI4bnh4OMaMGeN0mQcFBeG9996z6i0dUdXK21bmgPk8l/67oKBAsZ5ImRt7T5kyBf3798cjjzxicT0RM09JSUHdunWRm5tr00GkzA0GA2bPng29Xo+2bduipKTE6rd0RPIGzOf4zZs3AZR+s0E6nVYrb2tzpbi4GPn5+UhISFC4S6dcG3/7RSt3a5lLY65atcri48ZjOsLbGjqdDs8884z8d9H60xKJiYkAoPAGxOtPa5hmLlp/WsJa5oBY/WkN08yNvUXoT0vYylyk/rSGaeai9adab0Cs/rSEpbkiYn9awzRz0fozOzsbABASEmI2jouLC9zd3eX19u3bh6pVq6JFixbyOiNGjAAAnD17VvFcLd3DwsIU7gAwffp0NGzYsMzXF8lbtP5UO1ckROpPe+aKSP1pb+Yi9afazEXrz/uZKxJa9qfauSJif6rNXLT+PHjwILp27Ypq1arJy3x8fAAAO3fulLdDEfvTkntYWBhiYmIU7kDp76Cm86IiEfZSSBVNWloa2rdvD51Oh0mTJiE4OBjff/89Ro8ejezsbJvXCywsLAQAs9N6vb29AZRe10pi//798PPzQ0pKCvr16ye/kX7hhRfwr3/9S945nTlzBkQEDw8Ps9cLDQ3FyZMnNfd2cyudHgUFBYqdqlpEy7wsgoKCNPcuK3ODwYDU1FRcvHgRb7zxBgAoykTUzPPy8vCf//wH58+fx9WrV81eW9TMs7KykJmZCV9fX4SEhFi8zqJomZ87dw75+fkICAjA2LFjsXbtWvl05StXrgjrbYkNGzYAgKK8RZsrXl5eaNeuHY4fP46AgAAkJSUhMzMTc+fOBQBER0cL4Q6YZy6Nae3ardKYjvI2RTqFvUOHDor9nGj9aUpxcTEuXrwIAFY/SCgL0TIvC0f3pylqMhelPy15AdYzF6U/TSkrc5H60xRrmYvWn2q9LaFlf5piba6I2J+mWMtctP7s1KkTFi1ahNGjR+Odd95BtWrV5MwnT54sf0hy5swZlJSUICgoSPGBg/SBj/SBmpbuktdnn32mcFeLs3k7uj/VzhVjROlPezMXpT/tzVyk/lSbuWj9WZ7tU8v+VDtXROxPtZmL1p+FhYVm60kUFRUhISEB7du3F7I/rbl7e3sr3B1ChZ7/UInYunzGyJEjzU7lgMlpV6NHj6awsDDFaSJEREOGDCF/f3/Ky8uz+tpbt24lALRu3TrF8uXLlxMAatasmbysRYsW5O3tTd7e3vTiiy9Sjx495NN6hgwZIq+3efNmAkChoaFm3pGRkfJyrby3bt1KzZs3N/OWkDK3dSkH0TI39pYoLCwkABQQEEDFxcWaepeV+eDBg+V/FwCqWbOmU2Q+bNgwcnV1pTfffJOIiA4cOGB2KqqImY8aNYoeeOABCg4Opi+//JL69u0r/xtFznzbtm0EgFxcXKhhw4a0Zs0aWrNmjbxMOn1ONG8i8+0zOjqaANDMmTPlZSLOlYsXL1LVqlUV22dERITwc0UaMygoSDGmtK40pqO8TXniiScIAC1btkyxXLT+NGXHjh1yhpYQqT9NsZa5sbeElv1pSlmZi9SfptjKXKT+NMVW5qL1pynWMhetP9V6E4nVn6bYmiui9acp1jIXsT/nzp1LXl5eiixNM5f6s0ePHhZ/d/bx8ZH/rrX7jBkzzMY1nufWLoUkujeR9v2pZq5IiNafajMXrT/VZi5if6rJXMT+vN/tU+v+VDtXROxPNZmL1p/NmzenRo0aUUlJibxs/Pjxss+WLVuISMz+tOReWFhItWvXVribUhmXQvqfOLBgMBgoICCAxo4dS7dv31b8SDu83377zepr5+fnU506dSgkJIS2bt1KV69epY0bN1K1atXIzc2N6tevL68rbczjx49XeI8bN44AUGJiIhERffnllwSAwsLCzLxbtGhB/v7+mnobuxt7m2Zu7YMRETM39pYYM2YMAaBnnnlGc++yMh8+fDiFhITQjh07aM6cOdSyZUunyPyBBx4gV1dXysnJISLzN3YiZ25tvowePVpz97L2LQAoKSlJfr70xu7ZZ58V0ts07z///NPsjbSocyU1NZUiIiLI19eXtm3bRsuWLZMLfdq0aZq7W8s8Pz+ffHx8yMXFRTEmANLpdFS/fn2HepvSsGFDAmD2pky0/jRl6NCh5OLiUuZ7FhH60xRrmRt7S2jZn6aUlblI/WmKrcxF6k9T1M5zCS3705Sy9i2i9KdabyKx+tMUW3NFtP40xVrmIvbnunXr6PHHH6eVK1fS1q1bqWnTpgSAli5dKq8jzXFLHyoAIA8PD00yN3aXvgyh0+kU7kRlH1hwBm8i7ftTzVyREK0/1WYuWn/ak7lo/akmcxH78362TxH6U+1cEbE/1WQuWn9+9tlnBIBGjhxJZ8+epTNnzlCDBg3keSB9wC9if1pyf/rpp0mv1yvcTeEDCyp/eSFS/pKelpYmTwxrP9u2bbP5+gkJCRQZGSmv7+HhQR999BFVr16dHnjgAXm9qKgoAkC//PKLwvuXX34hALR27VoiUveNSy29jd2NvU0zt/bBiIiZG3sTES1evNisOJwhc4n4+HgCQEOHDtXc3VrmV65cIVdXV6pWrZr8XNM3ds6U+YULFwgAPfbYY5q7l7Vv8fT0VLwOAKpbty7Vq1dPSG/TvGfOnOkU22dxcTE1a9aMmjRpopgriYmJBIA6dOigubutzJ988kn5zYc0JgDy9vamBx54wKHexuTk5JCbmxsB5r0vWn+aent7e8sfdlhCpP40dbeWubE3kfb9aeqtNnMJLfvT1N1a5qL1p6m3vZlr2Z+m7mXtW0TpT7XeRGL1p6m3tbkiYn+autvKXKT+XL9+PXl5eVFycrK8TOp+b29v+cCI2m9caukuecfGxircico+sOAM3lr3p9q5YsmdSNv+VJu5aP1Z3sy17E+1mYvWn/e7fWrdn2rnioj9aU/mIvUnEdH06dMVPsHBwfJ/b9++nYjE7E9L7m3atKEZM2Yo3E2pjAML/xP3WJCujzls2DCMHDnS4jrG11CzRFRUFBISEnDu3DncuXMHkZGR8PLywksvvYSYmBh5vfDwcJw9e9bspiXSjVTu3LkDoPSmGgBw7949s9fKyclBeHi4EN4SkrdaRHA3zdyYL774Aq+//jrGjx+P5cuXC+UtUVbmHTp0AACcPn1aGHfTzGfOnAlvb294enrK17ZMTU0FANy9exdXr16Vr0vnDJnXqlULAJCfnw9AzMzDw8MBlN7gyRQfHx+kpKQI6W3K119/jcaNG+PPP/+Ul4ngLSF5//rrr0hISEC3bt3kexkAkG8umJycLIy7pcwDAgIQHh6OXbt2yWNWq1YNeXl5aNSokUO9jfnmm29QUlJi8THR+tPUOy8vD40bN8a1a9dsjm8NETM3RoT+NPW2N3Mt+9PU3VrmovWnqbe9mWvZn6bu1jIXrT/VepuidX+aelubKyL2p6m7rcxF6s9ly5ahVatWqFmzptkYeXl5OHnyJLp27Sr3p7QdmuLr6wvAsZlbc+/bty+++OIL2V0NonuL0J9q54o1tOxPtZmL1p/lzVzL/lSbuWj9eb/7Fa37U+1cEbE/7clcpP4EgPnz5+PVV1/F2bNn4e/vjxUrVuDTTz8FADRq1AgAhOxPS+7NmzfH9OnTFe6O4H/iwEJwcDB8fX1x79491W9MLKHT6RAVFSX/fffu3TAYDIoxo6OjsW/fPqSkpKBx48by8hs3bsguANCsWTPodDr55hzGpKamolu3bkJ4S0jeahHB3TRziby8PDz//PMYMGAAPv30U8UbOxG8jV3UIM0hEdxNM09KSkJOTg5ycnJQr149xevs3r0b9erVQ3p6uubeEmVlfvnyZQD/3DxHxMybN28OnU5n9UPX4OBgIb2NOXLkCC5duoQ5c+Zg5syZ8nIRvI1dgNKbMwEAEVl8LenNhQjutjI3HlOia9euDvU2Ji4uDnq9HsXFxWaPidafpt5VqlQx29/Zg4iZS4jSn6be95u5Fv1pjK3MRetPU297M9eyP03drWUuWn+q9TZGhP409bY2V0TsT1N3NZmL0J9paWkIDAy0OoZ0gKRZs2Zwc3NDenq64nHpJquhoaEAHJu5NXcpd7UH1ET3FqU/1c6VstCiP9VmLlp/ljdzLftTbeai9ef97FdE6E+1c0XE/ryfzEXoT4nAwEB07NhRsaxmzZpo0qQJADH705r7/v37Fe4OoULPf6hEynvz5tjYWHJ3d6czZ86YPf/WrVt2++Tl5VHr1q0pLCyMsrOz5eUnTpwg4J9rJkreQ4cOJTc3N0pJSZHXDQ8PJ1dXV8Xz8d9TWL7//ntNvY3dTb2J1N18UsTMpWu9PfbYY1RQUCCUt7G7sXdubi7dvXvXbJ5v2bKFANCjjz6qubu1zA8ePEiPPfYYBQcH0/bt22n79u00d+5cwn9P0du+fTsVFRUJl3lWVhYVFBQoMjcYDPT0008TABo7dqz8fNEyJyKqVasWAaDz58/Ly4DS6xZOmDBBWG8p78mTJxMAunTpkvDb57FjxwgA1a9fX7F9Hj9+nABQdHS05u5qMjceEwBVqVJFHtNR3sZjurm5UePGja32vkj9aeo9fPhwVe9ZROhPU3dbmYvUn6be1jIXsT9N3a1lLlp/mnpby1zE/jR1tzXPRepPe7xF6k9Tb2tzRcT+NHVXk7nxmFr1Z+/evcnd3Z3+/PNPeZmUuYuLi9nvQl5eXlS7dm152b///W8CQM8++6y8TCt3ybtfv35m7mpu3iyit0j9qXauiNifajMXrT/VZi5if9ozz0Xqz/vZr4jQn2rnioj9eb/7cmlMrX//NKZ79+4EgN5//33FctH60xIbNmyw6G4MXwqpHCxcuBAHDhxAu3btMGbMGERGRiIjIwMnTpzA/v37kZGRYfP5gwcPRnh4OCIjI5GdnY3Vq1fj8uXL2LVrl3zaCwC0atUKo0aNwurVq1FSUiKfdrd+/Xq8+eab8mliANC6dWvs3LkTMTExGDt2LK5fvw4AiIiIQI8ePTT1jomJwZ49ewAA06ZNU3ifPn0ap0+fRlZWFi5duoSsrCzMmzcPABSnjYmW+bVr1/Djjz9Cp9Nh0KBB2Lx5s9m/qUWLFsJlfvHiRXTt2hVBQUHIycnBp59+imPHjuGrr74CALRr107YzDt27IjatWvj8uXL6NevH4DSU98AoEaNGvIy0TI/ceIEhg4diqpVqyInJwcffPABtm/fjvj4eAD/nAonYuZA6b7l+vXr6Ny5MyZPniwv9/Lykk+NE9FbYuPGjWjfvj3q169v9phocyU6OhrdunXDvn374O3tjeXLl+PmzZtYunQpAKB9+/aau9vK/Oeff0ZGRgZWrlwpjwkA/fv3l8d0lLfExo0bUVJSgkaNGik6xRiR+tPU+9lnn8WOHTssjilaf5q6W8tctP409baWuYj9aepuLXPR+tPU21rmIvanqXtZ+xZR+tMeb+N1te5PU29rc0XE/jR1t5W5SP05bdo0fP/993jkkUcwadIkVKtWTc581KhRit6fP38+HnzwQaSmpmL58uW4fv06PvjgAwBAgwYNHJ65qfuZM2cAlF6K6vnnn1e437lzR+5NqUOB0stq7dixA3369BHOW7T+VDtXROxPtZmL1p9qMxexP+3ZPkXqT3u8JUToT7VzRcT+tCdzkfrz119/xZw5c9C9e3dUq1YNhw8fxr59+wAAU6ZMUYwpWn9acl+zZg169Ohh5n769Gl89913AGD2O+gDDzyAPn362HQqkwo9TFGJlPeMBaLSG2lMnDiRatWqRXq9nkJDQ6lLly60cuXKMl9/0aJF1KRJE/L09KTAwEDq27cvnTx50uK6RUVFNHv2bKpTpw65uLgQAPrXv/5l0Ts0NJQ6dOhAnp6e8k1C3njjDc299Xo9+fv7W8xcupu5pR/Tm4mIlLl00yZrP8bzRaTMb9++TWPHjiU/Pz/S6XTk7u5ODRs2pKlTpzrNPDfePk1vnqWlt7XML1++TE899RT5+PgQUHojoejoaFq+fLnTZB4WFkZdu3YlHx8f8vX1JQA0adIk4b2rV69OAOjjjz8mInH25bb2iXl5edSyZUvS6/Xk5eVF/v7+1Lt3b2HcbWUeHR1Nbm5uijG19CYiat++PVWvXp0mTJhgs/dF6k9j75KSEqvvWUTsT2N3a5mL2J/G3tYyF7U/jd3Lmuci9aext7XMRe1PY/eyMhepP+3xFqk/jb1t7RNF7E9jd1uZi9afR44coZ49e1JoaKjiPUtxcbHZuj169CAPDw+5P6X/PyK4S+9Z5s+fb+b+8MMPW+2hkSNHCuktYn+qmSui9qfauSJaf6rJXNT+tCdzkfrTHm+R+lPtvlzE/lSbuUj9eenSJerevTsFBQWRh4cHNWnShNq3b2+1+0XqT0vu7777LhUWFpqta+t3UOP+vF90RFYuzMUwDMMwDMMwDMMwDMMwDMMwDGOC+W3bGYZhGIZhGIZhGIZhGIZhGIZhrMAHFhiGYRiGYRiGYRiGYRiGYRiGUQ0fWGAYhmEYhmEYhmEYhmEYhmEYRjV8YIFhGIZhGIZhGIZhGIZhGIZhGNXwgQWGYRiGYRiGYRiGYRiGYRiGYVTDBxYYhmEYhmEYhmEYhmEYhmEYhlGNm9YCoqHT6aw+RkQONLEPZ/UGnNfdWb0B53Vnb8fjrO7O6g04rzt7Ox5ndXdWb8B53dnb8Tiru7N6A87rzt6Ox1ndndUbcF53Z/UGnNedvR2Ps7o7qzfg3O6m8BkLcrV85wAAMIBJREFUDMMwDMMwDMMwDMMwDMMwDMOohg8sMAzDMAzDMAzDMAzDMAzDMAyjGj6wwDAMwzAMwzAMwzAMwzAMwzCMavjAAsMwDMMwDMMwDMMwDMMwDMMwquEDCwzDMAzDMAzDMAzDMAzDMAzDqEZHzna7aYZhGIZhGIZhGIZhGIZhGIZhNIPPWGAYhmEYhmEYhmEYhmEYhmEYRjV8YIFhGIZhGIZhGIZhGIZhGIZhGNXwgQWGYRiGYRiGYRiGYRiGYRiGYVTDBxYYhmEYhmEYhmEYhmEYhmEYhlENH1hgGIZhGIZhGIZhGIZhGIZhGEY1fGCBYRiGYRiGYRiGYRiGYRiGYRjV8IEFhmEYhmEYhmEYhmEYhmEYhmFUwwcWGIZhGIZhGIZhGIZhGIZhGIZRDR9YYBiGYRiGYRiGYRiGYRiGYRhGNXxggWEYhmEYhmEYhmEYhmEYhmEY1fCBBYZhGIZhGIZhGIZhGIZhGIZhVMMHFhiGYRiGYRiGYRiGYRiGYRiGUQ0fWGAYhmEYhmEYhmEYhmEYhmEYRjX/Lw4sxMbGom7duoplOp0Os2fP1sRHLc7qDTivu7N6A87r7qzegPO6O4O3Mzhawlm9Aed1d1ZvwHnd2dvxOKu7s3oDzuvO3o7HWd2d1RtwXnf2djzO6u6s3oDzurO343FWd2f11gphDyzodDpVPz///LNDfIqLi/HOO+8gIiICHh4eiIiIwLx581BSUnJf3nv27MGFCxeQlpaGsLAw+Pr6olWrVgAAg8HgcG973J9//nns2rULycnJ8PT0RMOGDTF16tQKc7bX/X7nSmZmJqpXrw4AOHfunMO97XFv2bIl1q5di2vXrimWVzSVmfmCBQvQpEkTeHp6AgDi4uJw/fp1h3rb467T6axm/t1331WItz3u9mRORMjJyUHLli1RpUoVhISEAACSk5Mr1VutY5s2bZCRkWFx3J9//lnV/0c1/PDDDxg9ejSaNWsGV1dXszcHEvbO5+LiYvTo0QNVqlRB1apVAQB37941G9dgMGDx4sWoV68ePD090aJFC6xfv77CvO11z8rKQlpamuw9fPhwi2POnz8fffv2RUhIiN1voLTM/MKFC3jttdfQsmVL+Pr6IiwsDE888QSOHTtWYd72uqvJ/MaNGxg2bBgaN24MX19fBAQEoG3btli7di2IqMLcK2ueGxMXFwedTocqVaoI7X316lWr42zYsKFCvO11V7t9AsBff/2FZ555BtWrV4eXlxcaNmyIGTNm2PS2x70yMp89e7bNseLj48vtba+72sxv3ryJsWPHol69evDy8kL9+vXx8ssv4++//7Yetp3ulbV9Xrp0CYMGDUJgYCC8vb3RsWNHHDhwQBPv9PR0ZGRkIDo6Gnq9Hjqd7fexq1atQtOmTeXfNZYuXVph3va4f/bZZzh8+DBu3rxZpvdnn32Gp556CrVr14ZOp0NsbGyZzva6V0bmycnJeOedd9C2bVsEBgYiKCgInTp1wv79+yvM2x53tZnn5+fLr+3v748qVarggQcewEcffYTi4uIKc6/MeS7x22+/yeOkp6cL7W1tnIULF1aItz3u9myfAJCWloZx48ahRo0a8PT0RN26dTF69Gibz7HHvTIy/+KLL2yOFRcXV25ve9ztyTwrKwuvvfYaGjZsCC8vL9SpUwejR49GUlKS1efY615Z8zwtLQ3PPfec/F6rdevW2Lx5s8O9f/rpJ1y6dAm3bt1CrVq14OPjg2bNmgGA1d+RRenPN954Az/++COuX78ue8+bN8/imCL1pz2ZO6o/1XyuYDAY8MUXX6Bv374K73nz5qGgoECxbnn70xQ3u5/hINatW6f4+5dffol9+/aZLW/atCk+//zzCv0w3hLDhg3D5s2bMWrUKLRp0waHDx/G22+/jaSkJKxcuVJeb+7cuZgzZw6qVq2Kzp0749ixY7h48SI8PT0xZ84chIWFAQA8PT1x5MgRdO7cGT169ICfnx/27t2LP/74A99++y3mzJnjUO8TJ05Ar9fL3kSEb775BgUFBVi8eLHsDQDr169Hv3790LhxYwQGBuL8+fP4/PPPAQBFRUUV4m2Pu9rMTefKzJkzkZeXV2G+9nrbk/myZctQo0YNzJ07F3q9Xl5u64OHynS3J/Nly5ahT58+mD9/PsaMGYMWLVpg9OjRcHd3R1ZWFmrWrOkwb7WZFxYWoqCgAD4+PiAiOfM9e/YgLi4O9evXL7ezve72ZB4YGIiMjAz06tULEyZMQGZmJl5//XWsWbMG48aNQ9u2bSvF+8qVK+jUqZP8Bl3ab5tmHh8fj8TERIsfJP3yyy8YPXq0zSzU8vXXX2Pjxo1o3bo1wsPDra63bt06bNy4ETt37kSnTp2QlpaG8+fPAwAmTJiAhx56CEBptrNmzcLOnTtx6dIlLFiwALm5uZgxYwbWrVuH+fPnw93dXR53xowZWLhwIcaMGYMHH3wQ3377LZ555hnodDoMGTKk3N4A0Lt3b9k7IiIC3333HdLT0xXeAODv74+DBw8iPDwcU6ZMQW5uLt5//30AwL179xRjvvXWWwgNDUWrVq2wd+9em69/v+6Vkfm///1vrFq1CgMHDsSECROQlZWFFStWoH379tizZw+6du1abm+g4jNPT0/H9evXMWjQINSuXRvFxcXYt28fYmNj8eeff2LBggXCZm5Mbm4uXnvtNfj4+Nj0Fcl76NCh6NWrl2KZ8f/D8ngDlbN9/vHHH+jUqRNq1KiBV155BdWqVUNSUpKqA8daZj5gwAA0aNDA7LWmT5+O3NxcPPjgg+X2Bio+89zcXDz00EO4e/cuJkyYgFq1auHUqVP45JNPcODAARw/fhwuLta/p6Vl5snJyXjooYfg6uqKadOmwcfHB2vWrEH37t3x448/4tFHH3Wot9QpOp0OERERSExMtDruihUrMH78eAwcOBAvv/wyDh48iMmTJyMvLw+vv/56ub0B9XPljz/+wF9//YXmzZvj7t27Nr0XLVqEnJwctG3bFjdv3rT5+vfrXhmZf/vtt1i0aBH69euHkSNHoqSkBF9++SW6deuG1atX47nnniu3N1Dxmefn5+Ps2bPo1asX6tatCxcXF/znP//BSy+9hCNHjuDrr7+26aP1PJcwGAx48cUX4ePjU+YBfFG8u3XrhhEjRiiWSV+SLK83UDnbZ3JyMh5++GEAwPjx41GjRg3cuHEDR48etelij3tlZP7oo4+afQYGAP/6179w6tQpdOnSpdzeQMVnbjAY0K1bN5w7dw4TJkxAo0aNcOnSJSxbtgx79+7F+fPn4evrW273ysg8OzsbHTt2RFpaGqZMmYLQ0FBs2rQJgwcPRlxcHJ555hmHedetWxfx8fFo27Yt+vbti+rVq+PQoUM4e/YsvvrqK8ydO1dxgESU/iwoKMCYMWPQtm1bPP/88wgPD8ehQ4cwa9YsADD78pRI/WlP5o7qTzWfK+Tl5eG5555D+/btMX78eNl71qxZ+PHHH/HTTz/J3uXtTzPISZg4cSLZowuAZs2aVSGvffToUQJAb7/9tmL5K6+8Qjqdjk6dOiUv69WrFwUGBlJ6errCu0qVKjRgwAB5vdu3b1NCQoJFbwB08eJFTb2JiGJjYwmAwtsaW7ZsIQA0cODAcnuX191a5sacOXOG3NzcaM6cOQSAnnrqKc29iaxnHhMTQ1FRUWavJ/o8JyJatGgR6fV6OnLkiHDeRPbN8y5duhAAmjFjhubu1jIvLi4mLy8vGjRokGJMad8yefJkh3lLjqaZ37hxw8xbGvPRRx+1OaY9pKSkUFFRERERPfHEE1SnTh2L612/fp30ej1NnDhR4f3II49QzZo1qaSkRF73hRdeIC8vL7p27Zq8TMp2xYoVVsckIjIYDBbHrChvIqIJEyYQAFXe+/btIwDUu3dvxbhXrlwhotKesndb1TLzY8eOUU5OjuJ10tPTKTg4mB5++OFK8SaqmMwt0bt3b/Lx8bE5V8rjXhGZG/P6669T48aN6dlnnyUfH58y/31ael+5coUA0HvvvVemZ0V5E5V/rty7d4+aNWtG7dq1o7y8PIe5V/RckUhKSiKdTkdjxoypFG+i8mceFxdHAGjnzp2K15o5cyYBoBMnTlSKe0VkPmHCBHJzc6MLFy7Iy+7evUu1atWi1q1bO9w7NTVVnrfSepY6Ji8vj6pVq0ZPPPGEYrm0b8nIyKhwbyLrc8WSN5Hl97JXr14lg8FAREQ+Pj40cuRIq64V5V4RmSckJNDt27cVywoKCqhJkyZUs2bNSvEmqpjMLTFp0iQCQDdv3qwU94rI3JjPPvuMqlWrRlOmTCEAZv8vRPMGoPj/qBat50rPnj2pXr16it9JKtu9oueKRF5eHvn6+lK3bt0qxZuo/JnHx8cTAPrkk08Ur7V69WoCQNu2basU94rIfPHixQSAfvzxR3nZvXv36MEHH6TQ0FAqLCx0mHdhYSHFx8ebPV9y37dvn7xMpP605v3OO+8QABo+fLhiuUj9aU/mWvWnpc8Vysrc2NsaavvTFGEvhWQPlq5/ZYmUlBSMGjUKISEh8PDwQFRUFFavXl3m8w4ePAgAZt8wHTJkCIgIGzduVKzbtWtXVKtWTbFuTEwMdu7cidzcXABAUFAQ3nvvPave0pEzLb2lbx0ae0uYZi79t+kpNiJlbuw9ZcoU9O/fH4888ojF1xcx85SUFNStW9dsuSjugHnmBoMBs2fPhl6vR9u2bVFSUmL1LBERMzee5zdv3pQvH+DmpjzZS6TMi4uLkZ+fb/Wb5l5eXg71BmDmHRYWhoCAAGzbtk32lsaUTjOUkM5yeOihh+xyBIDw8HDFGT7W+Pbbb1FcXIwJEyYolr/wwgu4fv06Dh06JC9bs2YNdDodateurVi3atWq2LRpk/z3tWvXori4GBs2bJC916xZY3HMivSWvoVg+hpbt25F9erVFd9Qlb7Bf/bsWcW4er0eo0aNQmRkJIDSM6acIfPQ0FBMnjxZMZ+//fZbPPLII4pOrWjvisjc0raYl5eHvLy8Ms8E1DJzyTsoKAiLFi1Cfn4+rly5UqaL1t6pqakAgHfeeQceHh6IjIx0yBwv71z54YcfkJCQAD8/P9StW9ep9omW5vjLL78MIsKzzz5bad7lzTw7OxtA6TcAjd2leW7cqRXtDpQv859++gkBAQF49NFHZe8NGzagb9++OHHiBC5evOhQ79dffx1NmzYtc8zNmzfj77//Rnx8vGKOT5w4EXfv3sWuXbsqxdvaXAkJCcELL7yg6ndNNzc3jB49GiEhIbh79y6++eYbTbdPtZkHBATgtddeU8zxuLg49OrVC9evX0dOTk6leFdE5pb2Lbdu3QJQetlbW2iZueRdvXp1vPDCC9Dr9Zr2pz3eALB69Woh+lPtXLlw4QK+//57hIaGIjIy0qHuQMXMFdP+zMnJ0aQ/1WYu9efWrVsV7qdPnwagTX+qzfyHH36Ap6cnhg4dKnt/8cUXGDx4MFJTU/HLL784zNvd3R0rV65U9bmhSP3p7u6ODh06mH1u2L9/fwDA7du3FeOK1J/2ZK5lf1ry7tChg9nzpczL+n0Y+Odz3bL605T/FwcW1JCWlob27dtj//79mDRpEj766CM0aNAAo0ePxocffmjzuYWFhQDMd37e3t4AgOPHjyvWtbST9Pb2RlFRERISElT5BgUFCeENwKq3wWBAamqqfHoVAMXGp7W7tczz8vLwn//8B4sXL7b42lp7A5Yzz8rKwrVr1+Dr64vQ0FC8/fbbwrmbZn7u3Dnk5+fD3d0dY8eOhY+Pj/xBvvGbZ629AevzXGLDhg0WL7mmtbtp5l5eXggKCkJubi7i4uKQlJSkeAM3duxYh3pbWg8AXF1dAUD2lsY0PmiTlpYmX1YpPDzcLkd7OHnyJHx8fMzeaEqXjDp58iSA0jf2BQUF8PDwMBujRo0a8nppaWlYsGABdDodJk+erPCWPrCS1q0Mb+PHJe9bt27JvWKK8emmxvNCyr5q1apOkbm1+XzixAmr//aK8jZ+XPK2N/N9+/Zh1KhRmDlzJjw8PPDTTz+hTp06Zf7iVV73isi8atWqiIyMRMuWLfGf//znvq7N6UjvAQMGACjd7xcVFeH8+fMYPXo0xo8fX+nexo9L3mrnyrfffgsAOHXqFNzc3BTuZV0yqyLcK3r73LJli/zBd2V6Gz8ueavNXDrAunfvXjz55JOYPXs2fH19sW7dOjRr1gxNmjSpVPfyZH7p0iXk5OSY7ROl+4qZdnVleqslLS0NL774IgBg3LhxCu/4+Hi4uLg4tD/twXSeu7u7w8/PT7P+VIut/vz555/h7e0tv7+rDG/jx+3F2H3UqFGYNWsWfHx8sGnTJgQGBlq8/Nr9UJmZ16tXD2FhYXjwwQcr9B5ukldleAOl1xk37qCKvDxvZcyVbdu2AQAuXrwIHx8fhfvMmTPL5Wvq5ojtc/ny5dDr9fL7mcryNn7cXqRr5R88eBC9evXCO++8g8DAQHz44YeoVauWzUuU2kNlZH7w4EEUFxeb7RMPHz4MQKz+NP7c0Bn6U/pyj3GvOFt/qvms1hH9qdZbytzS+96ioiKkp6cjOTkZ27dvx/vvv486derY3Z/C3mOhopkxYwbu3buHM2fOyN+cHT9+PIYOHYrZs2dj3LhxVn95b9y4MQAgPj4e9erVk5dL37CVjtxL6x4+fBj37t2TPzgDgCNHjpita4r0rcSAgAD5WrNaehtfY9bUOz8/H8nJyfJ13aXr5BtPVhEzv3fvHjIyMvDaa6+hbt26uHr1qtlri5h5/fr1kZmZiRs3buCDDz7Ali1bLN74RrTMpW/DZWdn4+eff8aKFSsAAM899xy++uorvPLKK2jRooWQmZsSFxeHsLAws2v+iZY5ADzyyCPYtWsXhg0bpni9UaNGISIiwqHeAMy8pQIzXlca0/g64TNmzEB+fj6A0vvSjB8/XrWjPdy8eVO+UbEx0v7txo0b8noAFPlL+Pr6IiMjA4WFhZgxYwZKSkpQu3Zt+ZcVyfuTTz5RjFkZ3hKm3tayKigoQGFhITw8PBTzgoiwcOFCDBkyBH/++afwmVuaz127dsWPP/6IN954o9zOtrwlypP56NGjFfv1kJAQZGRkID8/X+jMP/jgA4wYMQKnTp1CZGQk6tWrh6tXrwrv3alTJzz99NOoUaMGLl++jOnTp2PFihXo3r17hfyiXhlzZffu3QBKz0zr1q0b+vfvj1OnTmHevHmYOXMmpk6dWiG/wDhi+3zkkUfw3XffIT8/HwUFBZU6VyTuJ/Mvv/wS/v7+ICL5fmJA6RdpkpOThZ7nrq6u8PDwwNSpU+Hr6yv3kHTzSVvveSraWy1Sf7q4uMg3gpW8582bh6pVqzq0P+3BdJ4vWrQInTt3RmFhoSb9eb/eQGnmvXv3xq5duzB06FCL862ivCXKk/k777wjf3EGKP1CRHFxMYqLi83OMr4fKivzDRs2oHPnzti9eze6d++O5s2bIyEhQX7vK6r3gw8+iGeffRb16tXDjRs38MYbb+Crr75CmzZtMGXKlErzlrifuSLd4PjevXto3LgxFi5ciKSkJLz55puYP38+pkyZYnZW+P3giO1z8ODBCA4OBmB+Fv39UhmZL1myBIGBgdDr9fjiiy/k5aGhocjOzhZ6+5S+vDFixAjUqVNH7qGtW7cCEKc/3d3d0bNnT9nbGfpT+nJvw4YN5WXO1J+mmWvZn2q9Fy9eDD8/P9nbmG3btmHo0KHy39u0aYPVq1fbvW3+T5yxQETYunUr+vTpAyJCenq6/PP4448jKysLJ06csPr8Xr16oU6dOnj11Vexbds2XLt2DZs2bZJ3OsblP2HCBCQmJsrfCPr7778B/POLgK03CpMmTZJfz83NTVPvhIQExZ3MTb09PDwQEhKCHTt2YM6cOWZHv0TN/MyZMwBKbxZoCVEzX7VqFVq2bAlvb28MHz4c3377LcaMGQOg9JQzrd2tZW58SaQff/wRsbGxiI2NlcdZvHixsJkbk5iYiOPHj5td+kfEzIHSS9no9XpMnDgR27Ztw7JlywCUnnWRnp7uUG8pP+PMR4wYIV8SS1pXuoHqDz/8gG3btuHq1avYsGEDCgoK4OrqitzcXLsc7SE/P9/itz89PT0VjtKflt5ISeWbl5eHrVu3olq1anB3d7eYrfFYleFt/Ljxn7be2OTn55vNC2mO5eXlOUXmpvP5/Pnzsm/nzp0r1dv4ceM/7cl8wIAB2LJlC5YvX44BAwagatWqyM7OFjrzXr164a233sLIkSNRvXp1pKeno0aNGgAgtHe/fv2wefNmDBo0CA899BCeffZZLFq0CAAwderUSvU2ftz4TzVzRfrFoVWrVvjwww8RExODyZMnY+DAgbh379593eTeHveK3D6lD+kLCwsrfa4YP278p9rts0OHDmjdujXmzZuHtWvX4oUXXkBSUpLw+8TOnTsjOzsb/fv3x08//YTDhw/j77//lr9QUZk9ZOqtBinvWrVqWe1PFxcXh/anWiy9ryIiFBQUaNaf9+udnp6uONv16aefrlRv48ftwdj94YcfxpYtW7Bq1SqMHDkSgYGByMnJET7zN998E126dEHr1q2Rnp6O+vXrA4Ccvajeu3fvxrPPPosOHTpg0KBB8o3v33rrLWG3z0uXLgEAqlevjrVr16Jz586IjY3F888/D4PBgPfee69czsZulb19fvHFFzAYDCguLnZ4f6pFcn/00UfRvHlzTJ8+HV9++SWmTZuGjIwM4feJPXr0gKurK/r374/du3fj999/lw9W2jtmZXhLZ6l27doVAQEBTtOfCxYskD97kf6dztKf1jLXsj/Veu/fvx8LFy5EQECA2eOPPfYY9u3bh82bN2P8+PHQ6/W4e/eu3Y7/E2cs3L59G5mZmVi5cqXVX7qkazFawtPTE7t27cLgwYMxcOBAAKUfrC9evBjz589HlSpV5HXHjx+P5ORk/F97dx8VVZ3/Afw9MDzHgwgqjz6FuZiMi7jKKvkQ4O5Bw0ioNOK07G5b7dl07eFo2Z7TbmUH1+wBxV2LSnMDY6lNy4cQfxaoi6YSretKk64jKpSmgy6E+P39wd7bXOaBQe7M3Nner3M6xNzbnXcfvnO/M/O99/stKSnBG2+8IT/+2GOPWe1rqaSkRP6QJY3eeTq3NBIOwCq3j48PAgMDMWfOHMyZMwe33norpk6din/961+ayA5Y1/zEiRNoampCRESE3b+Dp3M7qnlvS5YswZ///GcYjUZNZAesay6NLAcGBiIhIUHxfImJiaivr/d4bmdqLl3lsnDhQrzwwgvy457ODljX/OrVq9ixYwd8fHzkq+OBnoGJCxcuoKSkBEuWLHFbbqBnIM8yd1paGsaPH4/GxkZ5X6ljDAoKko9p6cSJE4q/VV8Z+yMoKEieismStGaM1I6ln0IIq32vXr0KoGcw7ZtvvpHnJeyd2fI5XZW793NIPy3vzrG1r732bPlhS8s1d9Se+1qbZqC5Lbdb/rzemluyvItnIFxR81dffRUAYDQa5X+XeGtbOXXqFEwmk3wnptq5Lbdb/nSmrUj/H7t27bJ5bpHuYBsod9fc1W3FcrvlT2dfnx9++CEAYPfu3Vb7HTx4EFOnTh1A6u+eT+2aS7lrampQU1NjtX9f7zPVzO0Mqd6O+k+17m5xtq04y965vKKiQl53yt3nRGc40wfZmgb0erir5paOHTvm1tenMyxzS3q3demu3oFyd1tpb2/HwYMHMW3atOsL/F+uaCvSzBDHjh3D0KFDrfZpaGjoX0gH2dxZc3f3n86Ssr/77rsAoLiQT7Jt2zbNvj6lOxMOHTqEnJwcq/082X9WVFTgySefBAB5lhNv6D+l3MXFxYrPDN7QfzqquSf7T2dzFxcX44EHHrC5z9ChQ+Vz4vz58/Hss88iKysLx48fx7Bhw5zO+L0YWJD+oPfccw+Kiops7pOSkuLwGOPGjUNTUxP+8Y9/4MKFC0hOTkZQUBAWL16M6dOnK/Z95pln8Mgjj+Dzzz9HaWmpYm72MWPGWB379ddfx+OPP45f/epXKCsr00Tu8PBwrFu3DqWlpXZzW5IWCZFG57RY86eeegrBwcEIDAyUp0CS5hu7fPkyTpw4AX9/f4/l7m/NpS/qpRFKLdY8NjYWQM9AVG8hISE4ffq0V7TzTZs24aabbsLEiRMVj2ux5nv27ME333xj801zVFQU6urqsHjxYo/lDg8Px/jx4+Xj9675gw8+iIKCAjQ3N2PevHm4++678fbbbyMjI8NqXZG+MjorJiYGtbW1EEIorgKV7gaR2rF0u6GtL6PMZjMiIyPlBZhuvPFGnDp1Cu+//77imC0tLSgqKpKP6Yrckt657V3NEBgYiICAAKv2fPHiRcyfPx+FhYW49957AWi75lLurq4uLF++HI2NjXjuuedgMBhcnlsy0JpbOnDgAJYuXWr3VmO1sg+k5nq9Hnl5eZg7d668z7p169DQ0ICEhAS0trZiyJAhmstt79z3t7/9DS+//DLOnz8/4IEFV7UVoOfqI+mDDdAzvVxOTg7CwsIGlLmv7GrVvKmpCYsXL0ZxcTHuuusuzb8+g4KCrOY+b25uxgMPPCB/me+q7GrUvKOjA0ajEXq9HqNHj8a2bduwevXqPt9nqpnbGVK9DQYDjhw5Is+TL+nq6kJOTo5b+09n2TqXz507FxkZGXjssccAuL//vN7cK1euxPbt27F06VLMmjXL7a9PZznqP00mE+677z75zsuBckXNg4ODMWXKFNx3333ytr/+9a+orq5GfHw8WlpaBtzWXd1WLO3fvx9PPvkkzp8/P6DMgOvaCgA8/PDDmDNnjmJ7fn6+wyuw+8PVNW9tbcXChQuRk5ODRYsWaf71CQBbt26Vv2MBevqqvLw81S76cWXNu7q6YDQa0d3djaSkJBw5cgRLly71WP+5c+dO3HvvvcjJycGWLVuscmu1/+zo6JBzl5WVKQYWtN5/9lVzT/afzua2/I65L/Pnz8cTTzyB9957D/fff7/T/933YmAhOjoaoaGh6O7uHtAiMTqdDuPGjZN//+CDD3Dt2jWbxxw0aBCmTZuGt99+G0DPKG18fLzVIm9XrlzBz3/+c+Tl5aG0tFTxR/dkbku2ctsjjaRpseb//ve/YTabYTabFfPCS8cdOXIkvvrqK6+puXSngjSfshZrPn78eOh0OrsfgKOjozXfzjs7O3Hy5Ek8/fTTVtu0WPNz584BsH0147Vr13D16lVN1LylpQW+vr5WNZeOOXbsWISGhqKlpQVCCCxcuFC1Rb56mzBhAtavX4+jR4/KC3UC3139O2HCBAA9C2MGBATYvGLg9OnTmDBhglzb8PBwNDc3Iy4uTnHMTZs2KY7pityW26Xc0dHRdq+Ak65G6N0upP1HjRqleu1dUfPu7m7MmjULCxYswOHDh1FZWanaonZ95bbcLuW+nppbkm5DVWtgQe2a33DDDWhvb0dlZSUqKyut9p00aRJyc3Plq9W0ktvRuW/btm0A7N9ppEZuy+1SbmfbSmBgIDo6OjB06FBFfun9wPDhwwec21F2tWpeVVUFnU6Hp556ComJiapkdpTbcruU29ma+/r6Qghh1V6kQRw11rRwlN0V7fzVV19FUFCQKleKOpvbGVJu6Vb9kJAQRf76+noIIdzafzrLVs19fX0RGxvrsf7zenI/+uij2L59O1avXq3KXPnO5Lbc3h+O2vmRI0cA2H4vfD1cUXOz2Yxdu3Zh165dVvtkZmbCYDDg8OHDmstt77zyz3/+U95voFzRVoKDg3HlyhWEhYUp8n/77bcwm80DvpjAMpsray5N2/j4448jIyNDlcyOcltu74/o6Gj4+fmhq6sLM2bMUPSV0tXnag3muLOd19bWAoAq5/X+5u7s7MTtt9+OtLQ0VFZWKmqq5f6zra0Nra2tSE9PR2VlpdXc/VruP52puSf7T3u59+/fr8jdn/USpItupOmbnfW9WGPB19cXd9xxB6qqqtDU1GS1va2trd/H/M9//oPly5cjJiZGsdiFPQ0NDVi0aJHiyu1z586hra0Nt9xyC9566y2rq7o9nVtaeNcy9+XLl+W50S1Jt4tJo2Wezg5Y1/wPf/gDZs6ciejoaFRXV6O6uhq///3vAfTccVFdXY2wsDDN1fzSpUtWHyCFEPIin9KK7VqseWhoKOLj49HZ2Sm/4ZScOnUKWVlZHs9tq+aWpC/3FixYYLXN09kB65pLV1DYmhvvq6++wg9/+EOP566oqMDXX3+NsLAwmzUHemqbm5uLPXv2ICoqyuqY15PRntzcXPj5+clrUUjKysoQFxcn35EF9HxxJy1eb+n8+fPIz8+Xa/vZZ59Br9crjimEwEsvvWR1TDVzSx+iez/HHXfcAZPJpBjkk6bGkAaHXNEu+pMdGFjNq6qqsGDBAlRUVGDNmjXyoIKrcw+05jk5OTZrLl3Nk5qa6rLswPXXfN68edDr9Vi9erXcp1ZXV2PmzJkICAhAdXU1li5dqrnc9tr46dOnsX79eqSkpMhXhaude6BtJTc3FwDwyiuvKK4GXL9+PQAgKytrwLntZQfUqXlXVxc2b96MadOmITExUfOvz6SkJHR0dKC8vFzxXH/5y18A9Kx34arsgPrtvL6+HlVVVSguLkZ4eLhbc/dFyr13716EhYVh7dq1iu0vvPACgoODbU5LoUZue22lP9m11n/2xTL3kiVLsHLlSixbtkz+UsRTr09ns9vrP6VzYlpa2gBT93BFzW31n9J83G+++aZi6lUt5bZVb7PZjD/+8Y+IioqyurtbrdxqvD4BoLy8XJ4+BOiZOaK7u9sj/aezuS1rvmnTJiQmJmLatGmaf30aDAYAPYs4W/Jk/9kXR+38+PHjWLNmDebMmaPKHQv9yX3x4kW0trZixIgR2LJli9XUN1rtP48ePYqamhro9XqbuS2za63/dLbmnuw/beU+evQocnJy7OaWSGtZ9Ha9/ef34o4FAFixYgVqa2sxefJk/OIXv0BycjLOnz+PTz/9FB999FGft+0VFBQgNjYWycnJuHTpEl577TUYjUZs3boVoaGh8n579uzB008/jezsbAwePFge1fzJT36iGLk6efIkampqoNPpMH/+fGzevFne1tjYiMbGRqSkpHgs9759+7Bz504AUOQ+fvw4MjMzERUVBbPZjNLSUhw4cAAbN24EAEyePFmzNZc+xBqNRsybNw8A5FHduLg4+TGt1fzTTz/F3XffjcjISPmNW3V1Nerq6gBA8QWI1moO9HwpZjKZMGvWLPzmN7+RHw8KCpIX0dZazSVCCFy+fBlTpkyRF1TrTWs1nzhxImJiYnDmzBnk5eUhOztbvk3Oz89PXpjUXbmBnqs6LGteXl6O2NhYeboGS9u2bUNsbCwuXbqE/fv3QwiB9vZ2LF++vN8ZGxsb5ekrmpubcfHiRXlAzmAwyNO3xMfHY9GiRSgpKUFXV5c82PTxxx/jrbfeUizwmZKSgubmZsycORMPP/ywfBvvkCFD5NvZpdq2tLSgtLQUjY2NiI6Oxt69e3HmzBmrY6qVe9KkSdi6dSuAnoXRLZ9j2bJlKC8vx9mzZ/Hyyy+jvb1dXjvB8iqHFStWYMuWLUhNTZU/EGzYsAHvvPMOjEYjjh496vCqaE/W/L333kNFRQWGDRuGffv2oaamBidOnMDnn3+OsrIy3H777QgJCdFczaV5WlNTU3HLLbcgLCwMDQ0NMJlMCAgIkAePtVbzlStX4uOPP8ayZcsU5xCj0YjOzk65T9Va7hUrVmDz5s0wGAyYNGkSkpKSYDKZUF9fj2+//RYvvviiS3Kr0VZefPFFbN++HYcOHcLIkSMxdepUfPHFF/j73/8Of39/xfRIWqu51N9kZmbi66+/xuDBg1FQUODSc7kaNV+/fj0yMjLws5/9DGvWrMFNN92EpqYmHDlyBHq9XvG+V2s137lzJwwGAyZPnowbb7wRRqMR+/btg06nkxchdGfu9vZ2+TgHDhyQH9+zZw82bNiAwsJCua2cOXMGW7ZswcSJEzFixAgcPHgQJ0+exDPPPIPIyEjVcztqKydPnkRjYyMuXrwo55aOKV0ZL9X8gw8+QGpqKtLS0tDR0YEdO3bg5ptvlmvvaFoET9Z869atWLVqFSIiInDmzBnceeediv4zKyvL5hSbnq55cnIy3nnnHaSmpiIjIwORkZE4fPgwmpub4efnh1mzZtmtt6drXltba9V/fvbZZwCAn/70p4iKitJk7urqahgMBqSlpWHMmDE4e/Ys6uvrceXKFWzcuFEx5Y1audVoKyUlJfjwww9hMpkwYsQIzJgxAy0tLfjkk0/kaR0d8XRbmTx5MvLy8tDY2Ijp06fjzjvv9Fj/6WzN33zzTdx8881Yvnw5qqqqMG7cOBw/fhwNDQ3ywsharnlKSgp+9KMfYcyYMTCZTKirq8PVq1f7nFZG7dxmsxk7duzAtWvXUFhYKP9dpOfau3cv0tPTNdd/ms1mzJ49G52dnYiIiFDkBpRryGmt/+xPzT3Vf7777rs2c8+ePRsXLlzAo48+alXz0aNHIz09HQCwceNGlJWVYd68eRg1ahTMZjO2b9+OnTt3Yu7cuX32n1aEl3jooYeEvbhFRUVi+PDhiscAiN/97neKx86dOyceeughkZCQIPz8/MSwYcPErbfeKv70pz/1+fzPP/+8GDt2rAgMDBSDBg0St912mzh06JDVfs3NzSI7O1tERUWJgIAAERERIQCIzs5OxX61tbUCgN1/LLN7IvfYsWPFlClTrGre1tYmfvnLX4qwsDCh0+mEv7+/SEpKEosWLdJ8zYWwbivS3yE/P9/jue3V3Gg0ivz8fBESEiIAiODgYDFx4kRRVlbmNTWPiYkRmZmZIiQkRISGhgoA4te//rXHc9uruSQzM1MAEC+99JL8mDfU/J577hEREREiOTlZBAUFifDwcAFA3H///W7NLZ23e9f8ueeeE4WFhTbP24MHD1Ycs6am5rozlpeX2z3HFhUVKfbt7u4Wzz77rBg+fLjw8fERAMTGjRutjllUVCRiY2NFdna2CA4Olv8OS5Yssartgw8+KNcegAgJCRHFxcUuy+3v7y8iIyPttufc3FwRGBgo5164cKHN9pyenm73+Wtra12SXY2aFxQUOOxXv/zyS9Vzq1HzHTt2iKysLBEcHCw/p5+fn0hOThbr1q1zWO+BZFernfd+fcbExAh/f39N5167dq2IjY2Vj6XT6UR0dLR44oknXJZbrdfn2bNnRUZGhtDr9QKA8PHxESNGjBBr1651WXY124rUzocOHeryc7laNa+rqxOjR48Wvr6+AoDw9fUViYmJ4pVXXnFZdjVqfuzYMTFy5Ej5WL6+vmL48OGK9zTuzD179my7x5w+fbq8n9RWBg0aJG8PCgoSBQUF4tq1ay7J7aitOPrM1vt9jKN+qLy83CXZ1aj5I4884rD/dNT3e7LmDQ0NYu7cueKGG26Qt+v1epGUlOSxc2J/27ll/zly5EgBQLS1tWk2d0VFhUhISFD0n5GRkeK3v/2ty+qt1uvz3LlzIjs7W/j5+Qmgp/+Mj4/3mnNiWFiYACCioqI82n/2p+aHDx8WP/jBD+T+08fHR8TGxopVq1a5LLtaNU9KSlLkjouLEytXrnR77i+//NLh+dnymFrqP/vKbTAYFPtrqf/sT8091X+OGzduQLkbGhpEfn6+SExMFAEBASIkJESkpqaKVatWia6uLof1tkUnhEqTDxIRERERERERERER0f+878UaC0REREREREREREREpA4OLBARERERERERERERkdM4sEBERERERERERERERE7jwAIRERERERERERERETmNAwtEREREREREREREROQ0DiwQEREREREREREREZHTOLBARERERERERERERERO03s6gNbodDq724QQbkzSP96aG/De7N6aG/De7Mztft6a3VtzA96bnbndz1uze2tuwHuzM7f7eWt2b80NeG925nY/b83urbkB783urbkB783O3O6XoNPBZPF7PIDdAFoBpGs4uzfX3Juz98Y7FoiIiDQkrp+PExEREREREV2P3egZTAC+G1QYDWCIh/KQd+HAAhERkYb8H757YyeJ/+/jRERERERERGoZjZ7BhHR8N6jwBYAZHktE3oQDC0RERBoivbGzddUIERERERERkVq+QM9nzXooBxVMDv4bIgkHFoiIiDREemO3G9ZXjRARERERERGppdDG7xxUIGdxYIGIiEhDZsD6qpFTfn68FZWIiIiIiIhUtcHG772n5iWyRye8bblpIiKi/3X19cDUqd/9XlcH/PjHnstDRERERERE/3t0OmDUKGDDBqCwEDAae37fvRtISPB0OtI4DiwQEREREREREREREZHTOBUSERERERERERERERE5jQMLRERERERERERERETkNA4sEBERERERERERERGR0ziwQERERERERERERERETuPAAhEREREREREREREROY0DC0RERERERERERERE5DQOLBARERERERERERERkdM4sEBERERERERERERERE77f4kOwUCTecREAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def visualize_image_with_tiles_and_centers(data_loader, img_idx=0):\n", + " \"\"\"\n", + " Visualizes an image alongside its corresponding tiles with hit centers overlaid.\n", + "\n", + " Parameters:\n", + " - data_loader: DataLoader, the instance of DataLoader to access image and center data.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " \"\"\"\n", + " # Get the image and corresponding centers\n", + " image = data_loader.images[img_idx]\n", + " centers = data_loader.centers[img_idx]\n", + " \n", + " # Tile the image and map the centers to the tiles\n", + " tiles, hits_per_tile = data_loader.map_hits_to_tiles(image, centers)\n", + " num_tiles_per_row = int(image.shape[0] / data_loader.tile_size) # Assuming square grid of tiles\n", + "\n", + " # Create a figure grid for the original image and its tiles\n", + " fig, axs = plt.subplots(num_tiles_per_row + 1, num_tiles_per_row, figsize=(15, 15))\n", + " fig.suptitle(\"Original Image and Tiles with Hit Centers\", fontsize=16)\n", + "\n", + " # Display the original image with centers\n", + " axs[0, 0].imshow(image, cmap='gray')\n", + " axs[0, 0].set_title(\"Original Image\")\n", + " axs[0, 0].axis('off')\n", + " for (_, x, y) in centers:\n", + " axs[0, 0].scatter(x, y, color='red', marker='x') # Plot hit centers on original image\n", + "\n", + " # Hide unused axes in the first row, if any\n", + " for j in range(1, num_tiles_per_row):\n", + " axs[0, j].axis('off')\n", + "\n", + " # Plot each tile with centers marked\n", + " for idx, tile in enumerate(tiles):\n", + " row = idx // num_tiles_per_row + 1\n", + " col = idx % num_tiles_per_row\n", + " axs[row, col].imshow(tile, cmap='gray')\n", + " axs[row, col].set_title(f\"Tile {idx}\")\n", + " axs[row, col].axis('off')\n", + " \n", + " # Plot centers within the tile\n", + " for (x, y) in hits_per_tile[idx]:\n", + " axs[row, col].scatter(x, y, color='red', marker='x') # Mark center within tile coordinates\n", + "\n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.9) # Adjust spacing to fit title\n", + " plt.show()\n", + "h = np.random.randint(0, 10000)\n", + "# Call the function with your DataLoader instance\n", + "visualize_image_with_tiles_and_centers(data_loader, img_idx=2) # Visualize the first image with centers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "d= DataLoader(file_path)\n", + "o =d.images\n", + "f = d.centers[:,:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10000, 50, 2)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(o[2], cmap='gray')\n", + "plt.scatter(f[2][:,0], f[2][:,1], color='red', marker='x', s=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(80000, 13, 1)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f[:,:,1:].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model definition" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# import tensorflow as tf\n", + "\n", + "# # Define the model\n", + "# def create_model(input_shape=(8, 8, 1), max_hits=3):\n", + "# model = tf.keras.Sequential([\n", + "# tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),\n", + "# tf.keras.layers.MaxPooling2D((2, 2)),\n", + "# tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + "# tf.keras.layers.Flatten(),\n", + "# tf.keras.layers.Dense(128, activation='relu'),\n", + "# tf.keras.layers.Dense(max_hits * 2),\n", + "# tf.keras.layers.Reshape(-1,max_hits,2)# Predict x and y for each hit, so output shape is (max_hits * 2,)\n", + "# ])\n", + "# return model\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "def create_model(input_shape=(8, 8, 1), max_hits=3):\n", + " # Define the input layer\n", + " inputs = tf.keras.Input(shape=input_shape)\n", + " \n", + " # First convolutional layer\n", + " x = layers.Conv2D(128, kernel_size=3, activation='relu')(inputs)\n", + " \n", + " # First max pooling layer\n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " \n", + " # Second convolutional layer\n", + " x = layers.Conv2D(64, kernel_size=3, activation='relu')(x)\n", + " \n", + " # Flatten the output\n", + " x = layers.Flatten()(x)\n", + " \n", + " # First dense layer\n", + " x = layers.Dense(128, activation='relu')(x)\n", + " \n", + " # Output layer: Predict x and y coordinates for each hit\n", + " outputs = layers.Dense(max_hits * 2)(x)\n", + " # outputs = layers.Reshape((max_hits, 2))(x)\n", + " \n", + " # Create the model\n", + " model = Model(inputs=inputs, outputs=outputs)\n", + " \n", + " return model\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Custom Loss Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(a) Sorting Algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + "# # Reshape reference_point to match the shape of midpoints for broadcasting\n", + "# reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + "# reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + "# # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + "# midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + "# # Calculate Euclidean distances from the reference point\n", + "# distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + "# # Get the sorted indices based on distances\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + "# # Gather the sorted midpoints\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# # Define the reference point (e.g., top-left corner)\n", + "# reference_point = (0.0, 0.0)\n", + " \n", + "# # Sort both y_true and y_pred based on Euclidean distances\n", + "# y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + "# y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + "# # Compute the difference\n", + "# diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss\n", + "# return tf.reduce_mean(powered_diff)\n", + " \n", + "# return loss\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "@tf.keras.utils.register_keras_serializable()\n", + "def euclidean_sorted_custom_loss(exponent=2):\n", + " def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + " # Reshape reference_point to match the shape of midpoints for broadcasting\n", + " reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + " reference_point = tf.reshape(reference_point, (1, 1, 2)) # Reshape to (1, 1, 2)\n", + " \n", + " # Reshape midpoints to (batch_size, num_midpoints, 2) for pairwise subtraction\n", + " midpoints = tf.reshape(midpoints, (-1, tf.shape(midpoints)[-1] // 2, 2))\n", + " \n", + " # Calculate Euclidean distances from the reference point\n", + " distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_midpoints)\n", + " \n", + " # Get the sorted indices based on distances\n", + " sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + " # Gather the sorted midpoints\n", + " sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + " return sorted_midpoints\n", + " \n", + " def loss(y_true, y_pred):\n", + " # Define the reference point (e.g., top-left corner)\n", + " reference_point = (0.0, 0.0)\n", + " \n", + " # Sort both y_true and y_pred based on Euclidean distances\n", + " y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + " y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + " # Create a mask to ignore ground truth values with (0,0)\n", + " nonzero_mask = tf.reduce_any(tf.not_equal(y_true_sorted, [0.0, 0.0]), axis=-1) # Shape: (batch_size, num_midpoints)\n", + "\n", + " # Apply the mask to filter out invalid points\n", + " y_true_masked = tf.boolean_mask(y_true_sorted, nonzero_mask)\n", + " y_pred_masked = tf.boolean_mask(y_pred_sorted, nonzero_mask)\n", + "\n", + " # Compute the difference only for valid points\n", + " diff = tf.abs(y_true_masked - y_pred_masked)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " \n", + " # Return the mean loss\n", + " return tf.reduce_mean(powered_diff)\n", + " \n", + " return loss\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_1 (InputLayer)      │ (None, 8, 8, 1)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 6, 6, 128)      │         1,280 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (MaxPooling2D)  │ (None, 3, 3, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (Conv2D)               │ (None, 1, 1, 64)       │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (Flatten)             │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (Dense)                 │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (Dense)                 │ (None, 6)              │           774 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_1 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,280\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m) │ \u001b[38;5;34m774\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 84,166 (328.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m84,166\u001b[0m (328.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 84,166 (328.77 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m84,166\u001b[0m (328.77 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "with strategy.scope():\n", + " model = create_model()\n", + " model.compile(optimizer='adam', loss=euclidean_sorted_custom_loss(exponent=2))\n", + " model.summary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Set up learning rate scheduler\n", + "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(\n", + " monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=5e-6\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "# Training pipeline with fixes for dataset issues and GPU allocation\n", + "steps_per_epoch = 8000*1024 // 4000\n", + "validation_steps = 2000*1024 // 4000\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Train model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:01:29.684065: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "2024-11-21 20:01:34.870378: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1732237294.989845 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.009726 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.009986 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.023703 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.023899 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.024209 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.024529 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.028381 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.028720 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.038835 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.039190 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.039616 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.040933 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.041295 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.041697 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.042276 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.042589 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.043032 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.043504 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.043978 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.044354 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.045814 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.046160 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.055837 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.056211 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.056596 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.056945 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.057393 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.057795 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.058315 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.058621 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.058995 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.059380 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.059801 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.060169 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.060536 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.060978 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.061368 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.061783 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.062232 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.063358 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.063787 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.064282 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.065671 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.066098 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.066598 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.067769 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.068172 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.069608 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.070003 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.070423 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.071682 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.072168 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.072660 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.074066 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.074548 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.075007 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.075979 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.076456 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.077054 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.082651 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.083118 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.083639 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.084821 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.085311 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.085838 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.090123 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.091423 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.092018 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.092344 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.093692 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.094344 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.095049 413898 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.537579 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.537939 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.538199 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.538912 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.539835 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.540110 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.540367 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.540624 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.540883 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.541155 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.541422 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.542438 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.542911 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.544118 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.544398 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.544691 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.545830 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.546125 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.546401 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.546690 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.547685 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.548018 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.553709 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.554049 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.554366 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.554706 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.555187 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.555681 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.558863 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.559981 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.568919 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.569219 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.569475 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.569897 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.570148 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.571063 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.571336 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.571585 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.571839 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.572102 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.572369 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.572629 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.572904 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.573370 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.573633 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.573902 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.574184 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.574468 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.574742 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.575017 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.575299 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.575603 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.575922 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.576966 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.577283 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.577592 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.577928 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.578395 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.578855 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.581981 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.583090 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.811562 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.812892 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.813314 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.813717 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.815447 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.815868 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.816273 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.816630 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.817007 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.817337 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.817749 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.818101 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.818543 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.818946 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.819416 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.819837 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.820264 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.820682 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.821042 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.821381 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.821713 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.822024 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.823826 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.824186 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.824531 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.824984 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.825219 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.825507 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.827299 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.827633 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.828028 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.829475 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.829817 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.830229 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.830538 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.830890 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.831197 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.831483 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.831839 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.832273 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.832507 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.832871 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.833205 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.833524 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.833948 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.834256 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.834606 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.834989 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.835345 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.835670 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.836011 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.837379 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.837704 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.838129 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.839450 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.839796 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.840183 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.840524 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.840873 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.841306 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.846399 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.846756 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.847482 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.847810 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.848587 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.848868 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.849340 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.849723 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.850196 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.851166 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.851547 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.852442 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.854065 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.855083 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.869920 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.871212 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.872408 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.875694 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.877493 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.879060 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.882385 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.885607 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.889068 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.902893 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.906404 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.913505 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.914974 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.915417 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.921969 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.922535 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.922853 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.923210 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.924083 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.924411 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.924872 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.926161 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.926514 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.926911 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.927695 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.928028 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.928418 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.928730 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.929111 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.929435 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.929972 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.930315 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.930796 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.932098 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.932422 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.932894 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.933224 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.933627 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.934115 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.934394 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.934730 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.935131 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.936289 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.936637 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.937005 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.938659 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.939002 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.939395 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.941011 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.941592 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.941972 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.943276 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.944353 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.945016 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.946228 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.946542 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.947580 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.948839 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.949281 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.949681 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.952204 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.953270 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.953895 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.955097 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.957614 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.959650 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.967676 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.969787 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.970598 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.975646 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.976387 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.976939 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.977872 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.978301 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.983188 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.983482 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.983964 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.984490 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.984763 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.985332 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.985805 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.986251 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.986697 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.987175 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.987595 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.988015 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.988972 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.989275 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.989722 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.994157 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.994588 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.995047 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.995522 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.995969 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.996456 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.997487 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.998037 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.998941 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.999446 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237295.999872 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.000649 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.001525 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.001997 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.002441 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.002988 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.003837 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.005022 413897 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.005641 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.006497 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.007404 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.007938 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.008801 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.010053 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.010717 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.011118 413902 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.011913 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 10/2048\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m35s\u001b[0m 18ms/step - loss: 0.2606" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1732237296.013217 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237296.013841 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0220" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:02:13.257749: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-21 20:02:13.257837: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-21 20:02:13.788489: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", + "W0000 00:00:1732237334.333208 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.333902 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.334193 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.335749 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.336033 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.336566 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.336867 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.337224 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.337717 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.338157 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.338654 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.338953 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.339389 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.339861 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.340174 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.340498 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.340889 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.341483 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.341886 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.342205 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.342664 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.343076 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.343406 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.343866 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.344247 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.344731 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.345006 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.345444 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.345778 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.346329 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.346626 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.346996 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.347439 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.347947 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.348378 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.348784 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.349253 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.352843 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.353174 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.353575 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.354210 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.354527 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.355003 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.355456 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.355812 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.356291 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.356825 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.357278 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.357851 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.358292 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.358489 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.359056 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.359527 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.360053 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.360369 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.360940 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.361246 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.361648 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.362767 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.363241 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.363615 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.366928 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.367452 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.367980 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.368838 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.369359 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.369872 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.370301 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.370668 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.371065 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.371518 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.371848 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.372369 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.372909 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.373512 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.374071 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.374576 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.374999 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.375436 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.375944 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.376389 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.376832 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.377207 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.377797 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.378214 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.378794 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.379260 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.379771 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.380222 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.380723 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.381222 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.381747 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.382136 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.382583 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.382995 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.383520 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.383906 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.384477 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.384970 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.385494 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.386037 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.386700 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.387361 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.387940 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.388400 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.389002 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.389501 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.391034 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.392537 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.394005 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.394735 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.395476 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.396185 413888 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.396731 413905 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1732237334.397204 413885 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 21ms/step - loss: 0.0220 - val_loss: 0.0093 - learning_rate: 0.0010\n", + "Epoch 2/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:02:18.890301: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0090" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:02:57.925761: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-21 20:02:58.386858: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0090 - val_loss: 0.0090 - learning_rate: 0.0010\n", + "Epoch 3/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0087" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:03:40.496192: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0087 - val_loss: 0.0087 - learning_rate: 0.0010\n", + "Epoch 4/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:03:44.554476: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0085" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:04:23.343194: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0085 - val_loss: 0.0086 - learning_rate: 0.0010\n", + "Epoch 5/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0084" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:05:05.594011: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 19ms/step - loss: 0.0084 - val_loss: 0.0086 - learning_rate: 0.0010\n", + "Epoch 6/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0083" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:05:46.328320: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-21 20:05:46.795658: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0083 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 7/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0083" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:06:28.294663: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0083 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 8/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0082" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:07:09.608159: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0082 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 9/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0081" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:07:51.566999: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0081 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 10/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0081" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:08:32.682918: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0081 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 11/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0081" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:09:12.729648: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0081 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 12/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:09:17.130979: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0080" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:09:53.521672: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0080 - val_loss: 0.0084 - learning_rate: 0.0010\n", + "Epoch 13/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0080" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:10:35.008882: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0080 - val_loss: 0.0084 - learning_rate: 0.0010\n", + "Epoch 14/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0079" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:11:20.605303: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m47s\u001b[0m 22ms/step - loss: 0.0079 - val_loss: 0.0084 - learning_rate: 0.0010\n", + "Epoch 15/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0079" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:12:04.708746: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0079 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 16/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0079" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:12:48.980293: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 21ms/step - loss: 0.0079 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 17/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0079" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:13:32.053159: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0079 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 18/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0078" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:14:21.038519: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 22ms/step - loss: 0.0078 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 19/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0078" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:15:05.952208: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 19: ReduceLROnPlateau reducing learning rate to 0.0009000000427477062.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0078 - val_loss: 0.0085 - learning_rate: 0.0010\n", + "Epoch 20/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0078" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:15:51.005012: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m46s\u001b[0m 22ms/step - loss: 0.0078 - val_loss: 0.0084 - learning_rate: 9.0000e-04\n", + "Epoch 21/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0077" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:16:36.133328: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0077 - val_loss: 0.0084 - learning_rate: 9.0000e-04\n", + "Epoch 22/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0077" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:17:20.368171: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-21 20:17:20.833347: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m46s\u001b[0m 22ms/step - loss: 0.0077 - val_loss: 0.0084 - learning_rate: 9.0000e-04\n", + "Epoch 23/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0077" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:18:05.547638: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0077 - val_loss: 0.0085 - learning_rate: 9.0000e-04\n", + "Epoch 24/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0077" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:18:49.593710: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0077 - val_loss: 0.0084 - learning_rate: 9.0000e-04\n", + "Epoch 25/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0076" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:19:35.913206: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m47s\u001b[0m 22ms/step - loss: 0.0076 - val_loss: 0.0084 - learning_rate: 9.0000e-04\n", + "Epoch 26/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0076" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:20:19.827865: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0076 - val_loss: 0.0085 - learning_rate: 9.0000e-04\n", + "Epoch 27/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0076" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:21:05.024599: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 21ms/step - loss: 0.0076 - val_loss: 0.0085 - learning_rate: 9.0000e-04\n", + "Epoch 28/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0076" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:21:50.666266: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 21ms/step - loss: 0.0076 - val_loss: 0.0086 - learning_rate: 9.0000e-04\n", + "Epoch 29/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0076" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:22:33.347374: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 29: ReduceLROnPlateau reducing learning rate to 0.0008100000384729356.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 21ms/step - loss: 0.0076 - val_loss: 0.0085 - learning_rate: 9.0000e-04\n", + "Epoch 30/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0075" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:23:18.370960: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 21ms/step - loss: 0.0075 - val_loss: 0.0085 - learning_rate: 8.1000e-04\n", + "Epoch 31/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0075" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:24:02.947076: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0075 - val_loss: 0.0085 - learning_rate: 8.1000e-04\n", + "Epoch 32/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0075" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:24:48.269361: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 21ms/step - loss: 0.0075 - val_loss: 0.0086 - learning_rate: 8.1000e-04\n", + "Epoch 33/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0075" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:25:33.442858: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 21ms/step - loss: 0.0075 - val_loss: 0.0086 - learning_rate: 8.1000e-04\n", + "Epoch 34/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0075" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:26:18.333821: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 21ms/step - loss: 0.0075 - val_loss: 0.0085 - learning_rate: 8.1000e-04\n", + "Epoch 35/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0074" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:27:02.806458: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0074 - val_loss: 0.0085 - learning_rate: 8.1000e-04\n", + "Epoch 36/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0074" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:27:45.516554: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0074 - val_loss: 0.0086 - learning_rate: 8.1000e-04\n", + "Epoch 37/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0074" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:28:30.314687: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 21ms/step - loss: 0.0074 - val_loss: 0.0086 - learning_rate: 8.1000e-04\n", + "Epoch 38/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0074" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:29:17.240590: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m47s\u001b[0m 21ms/step - loss: 0.0074 - val_loss: 0.0086 - learning_rate: 8.1000e-04\n", + "Epoch 39/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0074" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:30:01.722727: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 39: ReduceLROnPlateau reducing learning rate to 0.0007290000503417104.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 21ms/step - loss: 0.0074 - val_loss: 0.0086 - learning_rate: 8.1000e-04\n", + "Epoch 40/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:30:44.575133: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 20ms/step - loss: 0.0073 - val_loss: 0.0086 - learning_rate: 7.2900e-04\n", + "Epoch 41/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:31:28.324424: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 20ms/step - loss: 0.0073 - val_loss: 0.0085 - learning_rate: 7.2900e-04\n", + "Epoch 42/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:32:11.587948: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0073 - val_loss: 0.0086 - learning_rate: 7.2900e-04\n", + "Epoch 43/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:32:53.357545: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0073 - val_loss: 0.0086 - learning_rate: 7.2900e-04\n", + "Epoch 44/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:32:57.088349: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:33:36.695690: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m44s\u001b[0m 20ms/step - loss: 0.0073 - val_loss: 0.0086 - learning_rate: 7.2900e-04\n", + "Epoch 45/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:34:17.865219: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0073 - val_loss: 0.0086 - learning_rate: 7.2900e-04\n", + "Epoch 46/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:35:02.917823: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m46s\u001b[0m 22ms/step - loss: 0.0073 - val_loss: 0.0087 - learning_rate: 7.2900e-04\n", + "Epoch 47/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:35:46.196416: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0073 - val_loss: 0.0086 - learning_rate: 7.2900e-04\n", + "Epoch 48/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0073" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:36:27.701683: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0073 - val_loss: 0.0086 - learning_rate: 7.2900e-04\n", + "Epoch 49/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:37:10.669140: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 49: ReduceLROnPlateau reducing learning rate to 0.0006561000715009868.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0072 - val_loss: 0.0087 - learning_rate: 7.2900e-04\n", + "Epoch 50/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:37:53.535890: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 19ms/step - loss: 0.0072 - val_loss: 0.0088 - learning_rate: 6.5610e-04\n", + "Epoch 51/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:38:33.927750: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0072 - val_loss: 0.0088 - learning_rate: 6.5610e-04\n", + "Epoch 52/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:39:15.432162: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0072 - val_loss: 0.0087 - learning_rate: 6.5610e-04\n", + "Epoch 53/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:39:57.142099: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0072 - val_loss: 0.0087 - learning_rate: 6.5610e-04\n", + "Epoch 54/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:40:39.128857: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0072 - val_loss: 0.0087 - learning_rate: 6.5610e-04\n", + "Epoch 55/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:41:21.912320: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0072 - val_loss: 0.0087 - learning_rate: 6.5610e-04\n", + "Epoch 56/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:42:03.959426: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0072 - val_loss: 0.0088 - learning_rate: 6.5610e-04\n", + "Epoch 57/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:42:45.053927: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0072 - val_loss: 0.0088 - learning_rate: 6.5610e-04\n", + "Epoch 58/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0072" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:43:26.301407: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0072 - val_loss: 0.0087 - learning_rate: 6.5610e-04\n", + "Epoch 59/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:44:07.345859: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 59: ReduceLROnPlateau reducing learning rate to 0.0005904900433961303.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0071 - val_loss: 0.0088 - learning_rate: 6.5610e-04\n", + "Epoch 60/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:44:47.806198: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0071 - val_loss: 0.0088 - learning_rate: 5.9049e-04\n", + "Epoch 61/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:45:28.803301: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0071 - val_loss: 0.0088 - learning_rate: 5.9049e-04\n", + "Epoch 62/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:46:12.550893: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0071 - val_loss: 0.0088 - learning_rate: 5.9049e-04\n", + "Epoch 63/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:46:52.486807: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0071 - val_loss: 0.0087 - learning_rate: 5.9049e-04\n", + "Epoch 64/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:47:32.594062: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0071 - val_loss: 0.0088 - learning_rate: 5.9049e-04\n", + "Epoch 65/100\n", + "\u001b[1m2045/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:48:14.950035: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0071 - val_loss: 0.0088 - learning_rate: 5.9049e-04\n", + "Epoch 66/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:48:58.096270: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0071 - val_loss: 0.0087 - learning_rate: 5.9049e-04\n", + "Epoch 67/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:49:38.211348: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0071 - val_loss: 0.0088 - learning_rate: 5.9049e-04\n", + "Epoch 68/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0071" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:50:19.499653: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0071 - val_loss: 0.0088 - learning_rate: 5.9049e-04\n", + "Epoch 69/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:51:01.870374: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 69: ReduceLROnPlateau reducing learning rate to 0.0005314410547725857.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0070 - val_loss: 0.0088 - learning_rate: 5.9049e-04\n", + "Epoch 70/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:51:43.054463: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0070 - val_loss: 0.0088 - learning_rate: 5.3144e-04\n", + "Epoch 71/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:52:23.987525: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0070 - val_loss: 0.0089 - learning_rate: 5.3144e-04\n", + "Epoch 72/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:53:06.729708: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0070 - val_loss: 0.0090 - learning_rate: 5.3144e-04\n", + "Epoch 73/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:53:48.367535: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0070 - val_loss: 0.0089 - learning_rate: 5.3144e-04\n", + "Epoch 74/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:54:29.436208: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0070 - val_loss: 0.0089 - learning_rate: 5.3144e-04\n", + "Epoch 75/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:55:10.092591: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0070 - val_loss: 0.0089 - learning_rate: 5.3144e-04\n", + "Epoch 76/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:55:53.212216: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0070 - val_loss: 0.0089 - learning_rate: 5.3144e-04\n", + "Epoch 77/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:56:34.575653: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0070 - val_loss: 0.0089 - learning_rate: 5.3144e-04\n", + "Epoch 78/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:57:15.597869: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0070 - val_loss: 0.0090 - learning_rate: 5.3144e-04\n", + "Epoch 79/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0070" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:57:58.258231: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 79: ReduceLROnPlateau reducing learning rate to 0.00047829695977270604.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 20ms/step - loss: 0.0070 - val_loss: 0.0091 - learning_rate: 5.3144e-04\n", + "Epoch 80/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:58:40.487102: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.7830e-04\n", + "Epoch 81/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 20:59:20.631485: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0089 - learning_rate: 4.7830e-04\n", + "Epoch 82/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:00:00.525288: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.7830e-04\n", + "Epoch 83/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:00:41.583861: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.7830e-04\n", + "Epoch 84/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:01:22.394277: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0089 - learning_rate: 4.7830e-04\n", + "Epoch 85/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:02:02.457687: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.7830e-04\n", + "Epoch 86/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:02:42.319976: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-21 21:02:42.783201: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.7830e-04\n", + "Epoch 87/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:03:23.918861: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.7830e-04\n", + "Epoch 88/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:04:04.435288: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.7830e-04\n", + "Epoch 89/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:04:44.690352: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 89: ReduceLROnPlateau reducing learning rate to 0.0004304672533180565.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.7830e-04\n", + "Epoch 90/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 18ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:05:26.957290: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 20ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.3047e-04\n", + "Epoch 91/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:06:09.358409: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0091 - learning_rate: 4.3047e-04\n", + "Epoch 92/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:06:49.499146: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0091 - learning_rate: 4.3047e-04\n", + "Epoch 93/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:07:29.034450: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0090 - learning_rate: 4.3047e-04\n", + "Epoch 94/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0069" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:08:08.174209: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0069 - val_loss: 0.0091 - learning_rate: 4.3047e-04\n", + "Epoch 95/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0068" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:08:48.473996: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0068 - val_loss: 0.0091 - learning_rate: 4.3047e-04\n", + "Epoch 96/100\n", + "\u001b[1m2046/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0068" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:09:27.057547: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 19ms/step - loss: 0.0068 - val_loss: 0.0091 - learning_rate: 4.3047e-04\n", + "Epoch 97/100\n", + "\u001b[1m2045/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0068" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:10:07.264659: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0068 - val_loss: 0.0090 - learning_rate: 4.3047e-04\n", + "Epoch 98/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0068" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:10:46.689236: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 19ms/step - loss: 0.0068 - val_loss: 0.0091 - learning_rate: 4.3047e-04\n", + "Epoch 99/100\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0068" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:11:27.633797: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 99: ReduceLROnPlateau reducing learning rate to 0.00038742052274756136.\n", + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0068 - val_loss: 0.0091 - learning_rate: 4.3047e-04\n", + "Epoch 100/100\n", + "\u001b[1m2047/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 0.0068" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-21 21:12:08.708388: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m2048/2048\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 19ms/step - loss: 0.0068 - val_loss: 0.0091 - learning_rate: 3.8742e-04\n" + ] + } + ], + "source": [ + "# Training the model\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=100,\n", + " batch_size=4000,\n", + " callbacks=[lr_scheduler]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Training Results" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# import matplotlib.pyplot as plt\n", + "\n", + "# def plot_training_history(history):\n", + "# \"\"\"\n", + "# Plots the training and validation losses and MSE against epochs.\n", + "\n", + "# Parameters:\n", + "# - history: History object returned by model.fit, containing training metrics.\n", + "# \"\"\"\n", + "# epochs = range(len(history.history['loss']))\n", + "\n", + "# # Create a figure with two subplots\n", + "# plt.figure(figsize=(14, 6))\n", + " \n", + "# # Plot training and validation loss on a log scale\n", + "# plt.subplot(1, 2, 1)\n", + "# plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + "# plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + "# plt.yscale('log') # Logarithmic scale for loss\n", + "# plt.xlabel('Epochs')\n", + "# plt.ylabel('Loss (log scale)')\n", + "# plt.title('Training and Validation Loss (Log Scale)')\n", + "# plt.legend()\n", + "\n", + "# # Plot training and validation MSE\n", + "# plt.subplot(1, 2, 2)\n", + "# plt.plot(epochs, history.history['mse'], label='Training MSE')\n", + "# plt.plot(epochs, history.history['val_mse'], label='Validation MSE')\n", + "# plt.xlabel('Epochs')\n", + "# plt.ylabel('Mean Squared Error')\n", + "# plt.title('Training and Validation MSE')\n", + "# plt.legend()\n", + "\n", + "# plt.tight_layout()\n", + "# plt.show()\n", + "\n", + "# # Example usage after training\n", + "# plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# loaded_model = tf.keras.models.load_model('/home/da886/Final Electron counting project/Post Training Analysis/20KFixed_Mixed_5_64by64_Randomindex.keras')\n", + "# model.save('/home/da886/Electron Counting Tiling approach/Trained weights/10KFixed_100_256by256_RandomindexNoNoise.keras')" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "\n", + "# def predict_and_visualize(model, data_loader, dataset, img_idx=0, tile_size=8, max_hits_per_tile=5, threshold=0.5):\n", + "# \"\"\"\n", + "# Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " \n", + "# Parameters:\n", + "# - model: Trained Keras model for prediction.\n", + "# - data_loader: DataLoader instance to access image and tile information.\n", + "# - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + "# - img_idx: int, the index of the image in the dataset to visualize.\n", + "# - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "# - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + "# \"\"\"\n", + "# # Extract image and true centers from dataset\n", + "# images, true_centers = next(iter(dataset))\n", + "# image_tiles = images[img_idx * 16: (img_idx + 1) * 16] # Assuming 16 tiles per 32x32 image\n", + " \n", + "# # Make predictions on the tiles of the chosen image\n", + "# predictions = model.predict(image_tiles)\n", + " \n", + "# # Reshape predictions for visualization\n", + "# predicted_centers = predictions.reshape(16, max_hits_per_tile, 2) # 16 tiles, each with max_hits_per_tile hits\n", + "\n", + "# # Reconstruct the original image from tiles\n", + "# reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + "# image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, 4\n", + "# ) # 4x4 grid for a 32x32 image\n", + "\n", + "# # Visualize the original image with both true and filtered predicted hit centers\n", + "# fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + "# ax_orig.imshow(reconstructed_image, cmap='gray')\n", + "# ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + "# # Overlay true and filtered predicted centers on the reconstructed image\n", + "# for tile_idx in range(16): # 16 tiles for a 4x4 grid\n", + "# row_offset = (tile_idx // 4) * tile_size\n", + "# col_offset = (tile_idx % 4) * tile_size\n", + "\n", + "# # Plot true centers in green\n", + "# true_tile_centers = true_centers[img_idx *16 + tile_idx].numpy().reshape(-1, 2)\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot filtered predicted centers in red\n", + "# predicted_tile_centers = predicted_centers[tile_idx]\n", + "# for (x, y) in predicted_tile_centers:\n", + "# # Adjust the filter to be less restrictive\n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): # Less strict filter\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Add legend\n", + "# handles, labels = ax_orig.get_legend_handles_labels()\n", + "# ax_orig.legend(handles, labels, loc='upper right')\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Post Training Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", + "\n", + "# def predict_and_visualize(model, data_loader, dataset, img_idx, tile_size=8, max_hits_per_tile=13, threshold=0.5):\n", + "# \"\"\"\n", + "# Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + "# Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + "# Parameters:\n", + "# - model: Trained Keras model for prediction.\n", + "# - data_loader: DataLoader instance to access image and tile information.\n", + "# - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + "# - img_idx: int, the index of the image in the dataset to visualize.\n", + "# - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + "# - max_hits_per_tile: int, maximum number of hits per tile.\n", + "# - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + "# \"\"\"\n", + "# # Calculate the grid size based on the image and tile size\n", + "# grid_size = 64 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + "# # Extract image and true centers from dataset\n", + "# images, true_centers = next(iter(dataset))\n", + "\n", + "# # Adjust the indices to select the correct tiles for the image\n", + "# image_tiles = images[img_idx * grid_size**2: (img_idx + 1) * grid_size**2] # 64 tiles per image\n", + "\n", + "# # Make predictions on the tiles of the chosen image\n", + "# predictions = model.predict(image_tiles)\n", + "\n", + "# # Reshape predictions for visualization\n", + "# predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + "# # Reconstruct the original image from tiles\n", + "# reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + "# image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + "# ) # 8x8 grid for a 64x64 image\n", + "\n", + "# # Visualize the original image with both true and filtered predicted hit centers\n", + "# fig, ax_orig = plt.subplots(1, 1, figsize=(8, 8))\n", + "# ax_orig.imshow(reconstructed_image, cmap='gray')\n", + "# ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + "# # Overlay the tile boundaries\n", + "# for i in range(1, grid_size):\n", + "# # Horizontal lines\n", + "# ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "# # Vertical lines\n", + "# ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + "# # Overlay true and filtered predicted centers on the reconstructed image\n", + "# for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + "# row_offset = (tile_idx // grid_size) * tile_size\n", + "# col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + "# # Plot true centers in green\n", + "# true_tile_centers = true_centers[img_idx * grid_size**2 + tile_idx].numpy().reshape(-1, 2)\n", + "# for (x, y) in true_tile_centers:\n", + "# if (x, y) != (0, 0): # Ignore padding\n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + "# c='green', marker='x', s=40,\n", + "# label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Plot filtered predicted centers in red\n", + "# predicted_tile_centers = predicted_centers[tile_idx]\n", + "# for (x, y) in predicted_tile_centers:\n", + " \n", + "# if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size): \n", + "# ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + "# c='red', marker='o', s=30,\n", + "# label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + "# # Add legend\n", + "# handles, labels = ax_orig.get_legend_handles_labels()\n", + "# ax_orig.legend(handles, labels, loc='upper right')\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def predict_and_visualize(model, data_loader, dataset, img_idx, tile_size=8, max_hits_per_tile=3, threshold=3):\n", + " \"\"\"\n", + " Generates predictions for a single image, reconstructs it, and visualizes the true vs. predicted hit locations.\n", + " Also overlays the tile boundaries to visualize how the image is sliced into tiles.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model for prediction.\n", + " - data_loader: DataLoader instance to access image and tile information.\n", + " - dataset: tf.data.Dataset, the validation dataset containing image tiles and true centers.\n", + " - img_idx: int, the index of the image in the dataset to visualize.\n", + " - tile_size: int, size of each tile (e.g., 8 for 8x8 tiles).\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - threshold: float, minimum distance from the top-left corner for a hit to be considered valid.\n", + " \"\"\"\n", + " # Calculate the grid size based on the image and tile size\n", + " grid_size = 256 // tile_size # For 64x64 image and 8x8 tiles, grid_size = 8\n", + "\n", + " # Initialize variables to store the cumulative number of images processed\n", + " cumulative_images = 0\n", + "\n", + " # Iterate over the dataset to find the batch containing the desired image index\n", + " for batch_images, batch_true_centers in dataset:\n", + " # Calculate the number of images in the current batch\n", + " num_tiles_in_batch = batch_images.shape[0]\n", + " num_images_in_batch = num_tiles_in_batch // (grid_size ** 2)\n", + "\n", + " # Check if the desired image is in the current batch\n", + " if cumulative_images + num_images_in_batch > img_idx:\n", + " # Calculate the index of the image within the batch\n", + " batch_img_idx = img_idx - cumulative_images\n", + "\n", + " # Extract the tiles and true centers for the desired image\n", + " start_idx = batch_img_idx * grid_size**2\n", + " end_idx = (batch_img_idx + 1) * grid_size**2\n", + " image_tiles = batch_images[start_idx:end_idx]\n", + " true_centers_tiles = batch_true_centers[start_idx:end_idx]\n", + " break\n", + "\n", + " cumulative_images += num_images_in_batch\n", + " else:\n", + " # If we exit the loop normally, the image index was out of range\n", + " raise IndexError(f\"Image index {img_idx} is out of range.\")\n", + "\n", + " # Make predictions on the tiles of the chosen image\n", + " predictions = model.predict(image_tiles)\n", + "\n", + " # Reshape predictions for visualization\n", + " predicted_centers = predictions.reshape(grid_size**2, max_hits_per_tile, 2) # 64 tiles\n", + "\n", + " # Reconstruct the original image from tiles\n", + " reconstructed_image = data_loader.reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), tile_size, grid_size\n", + " ) # 8x8 grid for a 64x64 image\n", + "\n", + " # Visualize the original image with both true and filtered predicted hit centers\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(15, 15))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted and True Hits (Image {img_idx})\")\n", + "\n", + " # Overlay the tile boundaries\n", + " for i in range(1, grid_size):\n", + " # Horizontal lines\n", + " ax_orig.axhline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + " # Vertical lines\n", + " ax_orig.axvline(i * tile_size, color='yellow', linestyle='--', linewidth=0.5)\n", + "\n", + " # Overlay true and filtered predicted centers on the reconstructed image\n", + " for tile_idx in range(grid_size**2): # Loop over all 64 tiles\n", + " row_offset = (tile_idx // grid_size) * tile_size\n", + " col_offset = (tile_idx % grid_size) * tile_size\n", + "\n", + " # Plot true centers in green\n", + " true_tile_centers = true_centers_tiles[tile_idx].numpy().reshape(-1, 2)\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='green', marker='x', s=10,\n", + " label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot filtered predicted centers in red\n", + " predicted_tile_centers = predicted_centers[tile_idx]\n", + " for (x, y) in predicted_tile_centers:\n", + " if (x, y) != (0, 0) and (x >= threshold / tile_size or y >= threshold / tile_size):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size,\n", + " c='red', marker='o', s=10,\n", + " label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-22 11:54:28.242129: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t = np.random.randint(0, 100)\n", + "predict_and_visualize(model, data_loader, val_dataset, img_idx=t)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-15 15:04:35.894303: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-15 15:07:24.404991: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "\u001b[1m125/125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", + "True Positives: 97995\n", + "False Positives: 10142005\n", + "False Negatives: 524\n", + "Precision: 0.0096\n", + "Recall: 0.9947\n", + "F1 Score: 0.0190\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from scipy.optimize import linear_sum_assignment\n", + "\n", + "def compute_metrics(model, data_loader, val_dataset, tile_size=8, max_hits_per_tile=5, distance_threshold=0.1):\n", + " \"\"\"\n", + " Computes precision, recall, and F1 score for the model on the validation dataset.\n", + "\n", + " Parameters:\n", + " - model: Trained Keras model.\n", + " - data_loader: DataLoader instance.\n", + " - val_dataset: Validation dataset as a tf.data.Dataset.\n", + " - tile_size: int, size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - distance_threshold: float, the maximum normalized distance between predicted and true hits to consider a match.\n", + "\n", + " Returns:\n", + " - precision: float, precision score.\n", + " - recall: float, recall score.\n", + " - f1_score: float, F1 score.\n", + " \"\"\"\n", + " TP = 0 # True Positives\n", + " FP = 0 # False Positives\n", + " FN = 0 # False Negatives\n", + "\n", + " # Loop over the validation dataset\n", + " for batch_images, batch_true_centers in val_dataset:\n", + " # Make predictions on the batch\n", + " predictions = model.predict(batch_images)\n", + " num_tiles = batch_images.shape[0]\n", + "\n", + " # Reshape predictions and true centers\n", + " predicted_centers = predictions.reshape(num_tiles, max_hits_per_tile, 2)\n", + " true_centers = batch_true_centers.numpy().reshape(num_tiles, max_hits_per_tile, 2)\n", + "\n", + " # For each tile\n", + " for tile_idx in range(num_tiles):\n", + " pred_hits = predicted_centers[tile_idx]\n", + " true_hits = true_centers[tile_idx]\n", + "\n", + " # Remove padding (hits with coordinates (0, 0))\n", + " pred_hits = np.array([hit for hit in pred_hits if not np.allclose(hit, [0, 0])])\n", + " true_hits = np.array([hit for hit in true_hits if not np.allclose(hit, [0, 0])])\n", + "\n", + " if len(pred_hits) == 0 and len(true_hits) == 0:\n", + " continue # No hits to compare in this tile\n", + "\n", + " if len(pred_hits) == 0:\n", + " # All predicted hits are padding\n", + " FN += len(true_hits)\n", + " continue\n", + " if len(true_hits) == 0:\n", + " # All true hits are padding\n", + " FP += len(pred_hits)\n", + " continue\n", + "\n", + " # Compute cost matrix (distance matrix)\n", + " cost_matrix = np.linalg.norm(pred_hits[:, np.newaxis, :] - true_hits[np.newaxis, :, :], axis=2)\n", + "\n", + " # Apply threshold to cost matrix\n", + " cost_matrix[cost_matrix > distance_threshold] = np.inf\n", + "\n", + " # Check for NaN values in the cost matrix\n", + " if np.isnan(cost_matrix).any():\n", + " # Handle NaNs by setting them to infinity\n", + " cost_matrix = np.nan_to_num(cost_matrix, nan=np.inf)\n", + "\n", + " # Check if cost matrix is empty or contains only infinite values\n", + " if cost_matrix.size == 0 or np.isinf(cost_matrix).all():\n", + " # No feasible assignments\n", + " FP += len(pred_hits)\n", + " FN += len(true_hits)\n", + " continue\n", + "\n", + " try:\n", + " # Solve the assignment problem\n", + " row_ind, col_ind = linear_sum_assignment(cost_matrix)\n", + " except ValueError as e:\n", + " # Handle cases where the cost matrix is infeasible\n", + " FP += len(pred_hits)\n", + " FN += len(true_hits)\n", + " continue\n", + "\n", + " # Count matches\n", + " matches = 0\n", + " for i, j in zip(row_ind, col_ind):\n", + " if cost_matrix[i, j] != np.inf:\n", + " TP += 1\n", + " matches += 1\n", + " else:\n", + " # This shouldn't happen, but we'll account for it\n", + " pass\n", + "\n", + " # Count false positives and false negatives\n", + " FP += len(pred_hits) - matches\n", + " FN += len(true_hits) - matches\n", + "\n", + " # Compute precision, recall, and F1 score\n", + " precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n", + " recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n", + " f1_score = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0\n", + "\n", + " print(f\"True Positives: {TP}\")\n", + " print(f\"False Positives: {FP}\")\n", + " print(f\"False Negatives: {FN}\")\n", + " print(f\"Precision: {precision:.4f}\")\n", + " print(f\"Recall: {recall:.4f}\")\n", + " print(f\"F1 Score: {f1_score:.4f}\")\n", + "\n", + " return precision, recall, f1_score\n", + "\n", + "# Usage example:\n", + "\n", + "# Assuming you have your trained model, data_loader, and validation dataset\n", + "precision, recall, f1_score = compute_metrics(model, data_loader, val_dataset)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import random\n", + "\n", + "def visualize_dataset_images_with_tiles(images, centers, tile_size=8, max_hits_per_tile=5, image_indices=None, num_images=2):\n", + " \"\"\"\n", + " Visualizes specified or randomly selected images from a dataset along with all their tiles and hit locations.\n", + "\n", + " Parameters:\n", + " - images: np.array, tiled images with shape (num_images, num_tiles, tile_size, tile_size)\n", + " - centers: np.array, tiled hit locations with shape (num_images, num_tiles, max_hits_per_tile, 2)\n", + " - tile_size: int, the size of each tile (default is 8)\n", + " - max_hits_per_tile: int, the maximum number of hits per tile (default is 5)\n", + " - image_indices: list, indices of images to visualize. If None, `num_images` random images are selected.\n", + " - num_images: int, number of random images to visualize if `image_indices` is None (default is 2)\n", + " \"\"\"\n", + " num_available_images = images.shape[0]\n", + " \n", + " # Determine which images to visualize\n", + " if image_indices is not None:\n", + " selected_indices = [idx for idx in image_indices if idx < num_available_images]\n", + " else:\n", + " selected_indices = random.sample(range(num_available_images), min(num_images, num_available_images))\n", + "\n", + " for img_num, img_idx in enumerate(selected_indices, 1):\n", + " image_tiles = images[img_idx] # Shape: (num_tiles, tile_size, tile_size)\n", + " image_centers = centers[img_idx] # Shape: (num_tiles, max_hits_per_tile, 2)\n", + "\n", + " num_tiles = image_tiles.shape[0]\n", + " tiles_per_row = int(np.sqrt(num_tiles))\n", + " tiles_per_col = tiles_per_row\n", + "\n", + " # Adjust in case the number of tiles isn't a perfect square\n", + " if tiles_per_row * tiles_per_col < num_tiles:\n", + " tiles_per_col += 1\n", + "\n", + " # Create a figure for the current image\n", + " fig, axes = plt.subplots(tiles_per_col, tiles_per_row, figsize=(tiles_per_row * 2, tiles_per_col * 2))\n", + " fig.suptitle(f'Image {img_idx} - Tiles with Hit Locations', fontsize=16)\n", + "\n", + " # Flatten axes for easy iteration; handle cases where tiles don't fill the grid\n", + " axes = axes.flatten() if num_tiles > 1 else [axes]\n", + "\n", + " for tile_idx in range(num_tiles):\n", + " ax = axes[tile_idx]\n", + " tile = image_tiles[tile_idx]\n", + " tile_hits = image_centers[tile_idx]\n", + "\n", + " # Display the tile\n", + " ax.imshow(tile, cmap='gray')\n", + " ax.set_title(f'Tile {tile_idx}')\n", + " ax.axis('off')\n", + "\n", + " # Plot hit locations\n", + " for hit in tile_hits:\n", + " x, y = hit\n", + " if (x, y) != (0, 0): # Ignore padding hits\n", + " # Scale normalized hit coordinates if necessary\n", + " # Uncomment below if coordinates are normalized within tile\n", + " x *= tile_size\n", + " y *= tile_size\n", + " ax.plot(x, y, 'ro', markersize=2)\n", + "\n", + " # Debug output\n", + " print(f\"Image {img_idx} Tile {tile_idx} Hit (x, y): ({x}, {y})\")\n", + "\n", + " # Hide any unused subplots\n", + " for idx in range(num_tiles, len(axes)):\n", + " axes[idx].axis('off')\n", + "\n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.92) # Adjust top to accommodate the suptitle\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 1 Tile 5 Hit (x, y): (4.0, 3.0)\n", + "Image 1 Tile 6 Hit (x, y): (5.0, 2.0)\n", + "Image 1 Tile 11 Hit (x, y): (5.0, 7.0)\n", + "Image 1 Tile 11 Hit (x, y): (3.0, 5.0)\n", + "Image 1 Tile 12 Hit (x, y): (3.0, 4.0)\n", + "Image 1 Tile 18 Hit (x, y): (2.0, 5.0)\n", + "Image 1 Tile 18 Hit (x, y): (1.0, 3.0)\n", + "Image 1 Tile 20 Hit (x, y): (3.0, 0.0)\n", + "Image 1 Tile 23 Hit (x, y): (6.0, 6.0)\n", + "Image 1 Tile 27 Hit (x, y): (2.0, 0.0)\n", + "Image 1 Tile 33 Hit (x, y): (7.0, 6.0)\n", + "Image 1 Tile 37 Hit (x, y): (1.0, 7.0)\n", + "Image 1 Tile 48 Hit (x, y): (2.0, 4.0)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize images with indices 1701, 2301, and 6824\n", + "visualize_dataset_images_with_tiles(\n", + " images=val_images, \n", + " centers=val_centers, \n", + " tile_size=8, \n", + " max_hits_per_tile=5, \n", + " image_indices=[1]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"sequential\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d (Conv2D)                 │ (None, 6, 6, 32)       │           320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 3, 3, 32)       │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 1, 1, 64)       │        18,496 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 64)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 128)            │         8,320 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 10)             │         1,290 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m3\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m8,320\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m1,290\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 85,280 (333.13 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m85,280\u001b[0m (333.13 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 28,426 (111.04 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m28,426\u001b[0m (111.04 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Optimizer params: 56,854 (222.09 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m56,854\u001b[0m (222.09 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "loaded_model.summary()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sod", + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Electron Counting Tiling approach/Tiling images High Res .ipynb b/Electron Counting Tiling approach/Tiling images High Res .ipynb new file mode 100644 index 0000000..af4f383 --- /dev/null +++ b/Electron Counting Tiling approach/Tiling images High Res .ipynb @@ -0,0 +1,3588 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:03:33.724853: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-11-11 17:03:33.737701: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-11-11 17:03:33.750583: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-11-11 17:03:33.754422: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-11-11 17:03:33.765497: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-11-11 17:03:34.392029: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:03:38.921991: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 78643 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-11-11 17:03:38.923528: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79070 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-11-11 17:03:38.924872: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "\n", + "import tensorflow as tf\n", + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\",\"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "from sklearn.model_selection import train_test_split\n", + "from tensorflow.keras import layers, callbacks,regularizers\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_105982/3913266335.py:64: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Images Shape: (16000, 16, 16, 16)\n", + "Validation Images Shape: (4000, 16, 16, 16)\n" + ] + } + ], + "source": [ + "# Import necessary libraries\n", + "import numpy as np\n", + "import h5py\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "from tensorflow.keras import layers, Model\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "tf.random.set_seed(42)\n", + "\n", + "# Define the DataLoader class\n", + "class DataLoader:\n", + " def __init__(self, h5_filename, tile_size=16, max_hits_per_tile=5):\n", + " self.h5_filename = h5_filename\n", + " self.tile_size = tile_size\n", + " self.max_hits_per_tile = max_hits_per_tile\n", + " self.images, self.centers = self.load_data()\n", + " \n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'][:20000])\n", + " centers = np.array(f['centers_training'][:20000])\n", + " return images, centers\n", + " \n", + " def tile_image(self, image):\n", + " tiles = []\n", + " for i in range(0, image.shape[0], self.tile_size):\n", + " for j in range(0, image.shape[1], self.tile_size):\n", + " tile = image[i:i + self.tile_size, j:j + self.tile_size]\n", + " tiles.append(tile)\n", + " return np.array(tiles)\n", + " \n", + " def map_hits_to_tiles(self, image, centers):\n", + " tiles = self.tile_image(image)\n", + " hits_per_tile = {i: [] for i in range(len(tiles))}\n", + " \n", + " for hit in centers:\n", + " _, x, y = hit\n", + " tile_row = int(y // self.tile_size)\n", + " tile_col = int(x // self.tile_size)\n", + " tile_index = tile_row * (image.shape[1] // self.tile_size) + tile_col\n", + " \n", + " local_x = (x % self.tile_size)\n", + " local_y = (y % self.tile_size)\n", + " hits_per_tile[tile_index].append((local_x, local_y))\n", + " \n", + " return tiles, hits_per_tile\n", + " \n", + " def process_data(self):\n", + " tiled_images = []\n", + " tiled_centers = []\n", + " \n", + " for img_idx in range(len(self.images)):\n", + " image = self.images[img_idx]\n", + " centers = self.centers[img_idx]\n", + " tiles, hits_per_tile = self.map_hits_to_tiles(image, centers)\n", + " tiled_images.append(tiles)\n", + " \n", + " tile_hits_list = [hits_per_tile[i] for i in range(len(tiles))]\n", + " tiled_centers.append(tile_hits_list)\n", + " \n", + " return np.array(tiled_images), np.array(tiled_centers)\n", + " \n", + " def pad_hits(self, centers):\n", + " \"\"\"\n", + " Pads or truncates the hit coordinates for each tile to a fixed size (max_hits_per_tile).\n", + " \"\"\"\n", + " padded_centers = []\n", + " for image_centers in centers:\n", + " padded_image_centers = []\n", + " for tile_centers in image_centers:\n", + " # Pad or truncate to ensure exactly `max_hits_per_tile` hits per tile\n", + " padded_tile_centers = tile_centers[:self.max_hits_per_tile] + [(0, 0)] * (self.max_hits_per_tile - len(tile_centers))\n", + " padded_image_centers.append(padded_tile_centers)\n", + " padded_centers.append(padded_image_centers)\n", + " return np.array(padded_centers)\n", + " \n", + " def normalize_data(self):\n", + " tiled_images, tiled_centers = self.process_data()\n", + " # Ensure data type is float32 for TensorFlow compatibility\n", + " tiled_images = tiled_images.astype('float32')\n", + " normalized_images = tiled_images / np.max(tiled_images)\n", + " \n", + " # Normalize centers by scaling coordinates to the tile size and pad/truncate for TensorFlow compatibility\n", + " normalized_centers = [[[(x / self.tile_size, y / self.tile_size) for (x, y) in tile] \n", + " for tile in image_centers] for image_centers in tiled_centers]\n", + " padded_centers = self.pad_hits(normalized_centers)\n", + " \n", + " return normalized_images, np.array(padded_centers, dtype='float32')\n", + " \n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " normalized_images, normalized_centers = self.normalize_data()\n", + " return train_test_split(normalized_images, normalized_centers, train_size=train_size, random_state=random_state)\n", + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "tile_size = 16\n", + "max_hits_per_tile = 5\n", + "\n", + "data_loader = DataLoader(file_path, tile_size=tile_size, max_hits_per_tile=max_hits_per_tile)\n", + "\n", + "# Split the data\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "# Verify data shapes\n", + "print(f\"Train Images Shape: {train_images.shape}\") # Expected: (train_samples, num_tiles, 16, 16)\n", + "print(f\"Validation Images Shape: {val_images.shape}\")\n", + "\n", + "# Create TensorFlow datasets for training and validation\n", + "batch_size = 1000\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", + "\n", + "train_dataset = train_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=True).batch(batch_size)\n", + "val_dataset = val_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=False).batch(batch_size)\n", + "\n", + "\n", + "\n", + "def build_fixed_hits_model_with_confidence(input_shape=(16, 16, 1), num_hits=5):\n", + " output_units = num_hits * 3 # 2 coordinates + 1 confidence score for each hit\n", + " \n", + " inputs = layers.Input(shape=input_shape)\n", + " \n", + " # Convolutional layers\n", + " x = layers.Conv2D(128, (5, 5), activation='relu', padding='same')(inputs)\n", + " x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)\n", + " x = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(x)\n", + " \n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + " \n", + " # Fully connected layers\n", + " x = layers.Flatten()(x)\n", + " x = layers.Dense(64, activation='relu')(x)\n", + " \n", + " # Output layer with coordinates and confidence scores\n", + " coordinates_confidence_output = layers.Dense(output_units, activation='sigmoid', name='coordinates_confidence_output')(x)\n", + " reshaped_output = layers.Reshape((num_hits, 3), name='coordinates_confidence_output_reshaped')(coordinates_confidence_output)\n", + " \n", + " model = Model(inputs, reshaped_output)\n", + " return model\n", + "\n", + "# Create the model with confidence outputs\n", + "model_with_confidence = build_fixed_hits_model_with_confidence()\n", + "\n", + "# Adjust data shapes for model input\n", + "def prepare_dataset(dataset):\n", + " def reshape_function(images, centers):\n", + " # Reshape images to (batch_size * num_tiles, tile_size, tile_size, 1)\n", + " batch_size, num_tiles, tile_h, tile_w = images.shape\n", + " images = tf.reshape(images, (-1, tile_h, tile_w, 1))\n", + " centers = tf.reshape(centers, (-1, max_hits_per_tile, 2))\n", + " return images, centers\n", + " return dataset.map(reshape_function)\n", + "\n", + "train_dataset_prepared = prepare_dataset(train_dataset)\n", + "val_dataset_prepared = prepare_dataset(val_dataset)\n", + "\n", + "\n", + "import tensorflow as tf\n", + "\n", + "def custom_loss_with_count_penalty(y_true, y_pred, desired_hits=5):\n", + " # Separate coordinates and confidence from predictions\n", + " y_pred_coords = y_pred[..., :2] # Extract only (x, y) coordinates\n", + " y_pred_confidence = y_pred[..., 2] # Extract confidence scores\n", + "\n", + " # Calculate MSE for hit locations, ignoring padded zeroes in y_true\n", + " mask = tf.not_equal(y_true, 0)\n", + " y_true_masked = tf.boolean_mask(y_true, mask)\n", + " y_pred_coords_masked = tf.boolean_mask(y_pred_coords, mask)\n", + " location_loss = tf.reduce_mean(tf.square(y_true_masked - y_pred_coords_masked))\n", + "\n", + " # Calculate the number of confident predictions per image\n", + " # Here, we use a threshold (e.g., > 0.5) to consider a hit as a confident prediction\n", + " predicted_hits_count = tf.reduce_sum(tf.cast(y_pred_confidence > 0.5, tf.float32), axis=-1)\n", + " count_penalty = tf.reduce_mean(tf.square(predicted_hits_count - desired_hits))\n", + "\n", + " # Combine losses\n", + " total_loss = location_loss + 0.1 * count_penalty # Adjust the 0.1 weight to control penalty strength\n", + " return total_loss\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional_1\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional_1\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer_1 (InputLayer)      │ (None, 16, 16, 1)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (Conv2D)               │ (None, 16, 16, 128)    │         3,328 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_4 (Conv2D)               │ (None, 16, 16, 64)     │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_5 (Conv2D)               │ (None, 16, 16, 128)    │        73,856 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (MaxPooling2D)  │ (None, 8, 8, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (Flatten)             │ (None, 8192)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 64)             │       524,352 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ coordinates_confidence_output   │ (None, 15)             │           975 │\n",
+       "│ (Dense)                         │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ coordinates_confidence_output_… │ (None, 5, 3)           │             0 │\n",
+       "│ (Reshape)                       │                        │               │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_1 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m3,328\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_4 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_5 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8192\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m524,352\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ coordinates_confidence_output │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m15\u001b[0m) │ \u001b[38;5;34m975\u001b[0m │\n", + "│ (\u001b[38;5;33mDense\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ coordinates_confidence_output_… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 676,303 (2.58 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m676,303\u001b[0m (2.58 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 676,303 (2.58 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m676,303\u001b[0m (2.58 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:29.666793: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-11 17:04:29.679139: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-11-11 17:04:29.725156: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1731344669.832902 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.835555 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.843248 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.896382 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.896463 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.896523 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.918493 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.918673 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.919308 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.921435 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.921861 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.922797 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.922810 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.923163 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.924076 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.935786 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.935897 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.935912 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.942943 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.943103 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.944038 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.959662 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.959769 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.959790 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.962601 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.962712 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.962742 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.964820 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.965058 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.965173 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.967374 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.967677 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.968447 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.973368 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.973488 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.973879 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.979258 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.979344 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.979714 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.983279 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.983338 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.983490 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.992026 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.993409 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.993719 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.996362 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.996923 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344669.997662 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.001834 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.001848 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.002093 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.011340 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.011345 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.011563 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.024452 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.024597 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.024690 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.108427 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.109327 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.109721 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.112955 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.113872 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.114239 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.117338 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.118259 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.118589 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.121859 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.122791 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.123084 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.127484 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.128414 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.128694 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.135501 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.136520 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.136716 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.146796 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.148024 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.148033 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.158100 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.159355 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.159460 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.169259 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.170427 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.170630 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.181276 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.182330 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.182652 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.202975 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.203818 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.204350 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.224625 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.225251 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.226001 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.406356 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.406772 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.408275 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.409302 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.409708 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.411234 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.412894 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.413277 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.414824 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.416131 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.416512 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.418076 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.419719 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.420096 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.421721 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.423391 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.423753 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.425404 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.428887 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.429237 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.430914 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.434989 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.435368 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.437037 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.439070 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.439396 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.441093 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.443536 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.443900 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.445606 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.450492 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.450800 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.452561 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.454920 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.455188 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.456984 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.458965 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.459206 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.461034 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.463527 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.463752 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.465484 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.471235 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.471447 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.473164 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.477447 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.477461 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.479069 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.483370 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.483465 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.484844 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.488432 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.489948 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.490286 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.493268 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.494802 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.495381 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.500225 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.508225 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.508236 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.513161 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.515273 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.515372 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.519807 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.528315 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.528329 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.532669 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.546623 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.546844 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.551087 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.568767 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.572022 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.573513 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.574676 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.575253 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.576786 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.577934 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.578988 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.580519 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.581165 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.582176 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.583748 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.584884 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.586928 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.587528 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.588030 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.592245 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.593324 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.598850 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.603560 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.604525 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.610211 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.614908 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.615765 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.621422 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.626126 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.626862 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.632449 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.637148 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.637769 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.643508 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.648211 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.648718 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.655602 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.660274 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.660674 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.822414 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.824837 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.826444 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.826553 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.827654 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.828897 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.829065 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.831110 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.831732 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.831899 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.834792 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.835184 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.835386 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.838528 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.838864 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.839063 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.842696 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.842824 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.842922 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.846483 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.846855 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.847042 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.850707 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.850911 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.851008 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.854949 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.855124 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.855418 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.859652 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.859848 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.860309 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.864524 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.864764 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.873085 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.877229 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.877653 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.878402 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.882527 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.882994 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.883566 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.887593 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.888157 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.888502 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.892489 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.893090 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.894267 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.898211 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.898847 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.900514 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.904393 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.905086 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.907489 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.911301 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.912035 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.914694 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.918441 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.919238 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.920836 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.924529 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.925366 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.933301 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.933607 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.937204 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.946068 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.946353 106371 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.949881 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344670.958926 106379 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.466921 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.466942 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.470769 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.472062 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.472140 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.474351 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.477357 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.477427 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.479495 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.482940 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.482958 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.484012 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.487490 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.487591 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.488429 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.492033 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.492220 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.492972 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.498013 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.498370 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.498432 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.502652 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.503214 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.503281 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.507410 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.508153 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.508219 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.511086 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.511993 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.512067 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.514779 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.515852 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.515917 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.520366 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.521068 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.521150 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.525650 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.526542 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.526617 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.533568 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.534675 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.534742 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.539609 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.540904 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.540971 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.546849 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.548356 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.548423 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.553362 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.555054 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.555130 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.560633 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.562525 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.562624 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.571742 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.573914 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.573978 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.582773 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.585203 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.585270 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.595337 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.597907 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.600412 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.615824 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.615851 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.616093 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.629434 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.629655 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.629837 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.796314 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.797053 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.797265 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.799943 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.800686 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.800910 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.803718 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.804893 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.805838 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.808389 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.808798 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.809636 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.812885 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.813698 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.813813 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.817470 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.818454 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.818531 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.822219 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.823391 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.823518 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.826886 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.828249 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.828327 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.831771 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.833304 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.833379 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.836917 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.838650 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.838716 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.841968 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.843959 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.843971 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.848276 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.849735 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.849803 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.853247 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.854797 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.854874 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.859303 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.861044 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.861161 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.865376 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.867316 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.867338 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.871417 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.873505 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.873574 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.880146 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.882396 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.882477 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.885888 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.888200 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.888414 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.897166 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.899494 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.900002 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.926370 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.926484 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.926970 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.932055 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.932240 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.932698 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.937980 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.938047 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.938326 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.943840 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.943933 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.944048 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.949499 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.949623 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.949721 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.955825 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.956096 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.957453 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.961902 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.963261 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.964713 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.967521 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.969061 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.970583 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.972414 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.973938 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.975418 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.977965 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.979485 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.980917 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.982764 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.984292 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.985675 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.989046 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.990585 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.991914 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.994008 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.995565 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344671.997109 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.002368 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.003971 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.005420 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.010672 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.012256 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.013655 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.017411 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.018957 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.020354 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.023459 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.025002 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.026353 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.028818 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.030364 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.031666 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.039861 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.041380 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.042687 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.049090 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.050586 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.051850 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.058344 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.059792 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.061014 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.068039 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.069514 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.070636 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.090472 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.092147 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.093033 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.104901 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.106118 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.106848 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.118634 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.119886 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.120445 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.132327 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.133634 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.134028 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.146035 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.147385 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.147663 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.162014 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.163483 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.163571 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.177959 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.179487 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.179585 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.196620 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.197961 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.198520 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.439482 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.442655 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.442665 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.444334 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.447623 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.447701 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.449080 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.452568 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.452586 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.453910 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.457585 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.458960 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.462246 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.465968 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.467595 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.467706 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.471046 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.472823 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.475327 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.478783 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.480347 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.480641 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.483779 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.485655 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.494733 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.498357 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.500358 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.513733 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.517071 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.519249 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.535362 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.538888 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.541229 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.552774 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.556518 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.558813 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.585285 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.588513 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.591597 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.591627 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.591792 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.594911 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.595217 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.595231 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.598045 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.598376 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.598952 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.601313 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.601652 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.602066 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.605056 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.605441 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.605541 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.608201 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.608696 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.610107 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.611428 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.611938 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.613837 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.616099 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.616628 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.618423 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.619832 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.620380 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.622205 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.624427 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.624991 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.625811 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.628212 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.628788 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.629901 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.631828 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.632423 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344672.634392 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.356773 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.356822 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.361548 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.361619 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.907780 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.913325 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.918499 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.918992 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.924591 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.929835 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.930142 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.935801 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.941088 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.941496 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344673.947217 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.516477 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.516485 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.527303 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.528092 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.528312 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.538825 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.539853 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.540294 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.550882 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.552059 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.553033 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.563610 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.564932 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.578451 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.588409 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.589720 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.726540 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.730228 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.733781 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.737202 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.737967 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.739158 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.740898 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.741690 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.742892 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.744731 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.745269 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.746488 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.748918 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.749026 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.749940 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.752774 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.753017 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.753669 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.756615 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.757159 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.757529 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.760678 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.761247 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.761568 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.764821 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.765354 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.765671 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.768994 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.769863 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.770486 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.773104 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.773989 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.775879 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.777235 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.778129 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.781555 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.782404 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.783300 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.787589 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.787838 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.788694 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.793536 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.794390 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.795056 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.799597 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.800458 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.801147 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.807084 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.808010 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.813217 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.814158 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.818227 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.830428 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.831118 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.842416 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.848505 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.853203 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.854893 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.856176 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.857934 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.861041 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.862307 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.863307 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.865777 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.867043 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.868641 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.870552 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.871840 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.874922 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.875959 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.877284 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.881346 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.881644 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.882679 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.887468 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.887696 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.888983 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.893304 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.894422 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.895698 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.899285 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.900298 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.901596 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.905268 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.906174 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.907481 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.912206 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.912633 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.913533 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.918241 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.919588 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.920001 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.925658 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.927001 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.927688 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.933095 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.934430 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.935365 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.940785 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.941009 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.942157 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.946154 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.948799 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.949872 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.954225 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.954517 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.955341 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.959645 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.960075 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.960786 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.965623 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.968056 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.969189 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.973666 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.974801 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.976535 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.979262 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.980422 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.990257 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.991441 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344674.992316 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.006217 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.008080 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.010074 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.022197 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.026000 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.026538 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.040849 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.041904 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.052117 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.066693 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.067733 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.077721 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.092521 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.093521 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.103324 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.118384 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.119332 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.344635 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.350720 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.355555 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.360774 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.362214 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.365807 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.368528 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.368533 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.372022 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.372950 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.373452 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.376968 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.378485 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.378720 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.385165 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.385181 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.386418 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.390855 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.392887 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.394314 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.396427 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.397356 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.402721 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.402997 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.409217 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.409349 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.411935 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.418599 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.426927 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.428178 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.433751 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.442757 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.446119 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.453058 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.460860 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.461060 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.467824 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.479373 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.482660 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.486271 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.501216 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.508124 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.532256 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/16\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2:34\u001b[0m 10s/step - loss: 2.2494" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731344675.551267 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.558180 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.626513 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.632559 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.634838 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.636536 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.641893 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.645258 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.646330 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.648353 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.650184 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.652424 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.653978 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.654034 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.654735 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.655884 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.656453 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.658924 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.660316 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.661882 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.662657 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.663580 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.664403 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.665305 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.667814 106372 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.668438 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.669857 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.670158 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.673268 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.674055 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.675909 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.677115 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.679068 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.679117 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.682989 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.683823 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.684875 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.688185 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.688322 106382 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.693038 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344675.697410 106373 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 47ms/step - loss: 1.5546" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:36.377005: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-11 17:04:36.377079: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-11-11 17:04:36.377196: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n", + "W0000 00:00:1731344676.922625 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.923061 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.924404 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.925094 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.926003 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.926970 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.929159 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.929176 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.929746 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.930805 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.931152 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.931601 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.932817 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.933188 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.933420 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.934503 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.934696 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.935238 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.935999 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.936247 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.937276 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.937577 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.937750 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.939008 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.939453 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.939573 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.940687 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.941197 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.941201 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.942749 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.942886 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.943188 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.944642 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.944645 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.944877 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.946379 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.947871 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.948369 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.948535 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.949964 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.950799 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.951078 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.951724 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.952761 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.953983 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.954753 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.955474 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.956676 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.957169 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.958569 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.959407 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.959818 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.961617 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.962184 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.962914 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.964320 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.964969 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.965353 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.966357 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.967712 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.968449 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.969078 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.970454 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.971185 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.973220 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.975955 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.977558 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.978386 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.978999 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.979594 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.979848 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.981061 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.984498 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.984813 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.985333 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.986264 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.986543 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.988239 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.989734 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.990681 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.991752 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.992426 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.994853 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.995214 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.996644 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344676.997752 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.000236 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.001968 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.002348 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.007479 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.012663 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.014869 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.020053 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.020224 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.022461 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.025440 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.027755 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.027770 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.033079 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.038843 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.040755 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.042239 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.044150 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.045474 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.045652 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.047561 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.048858 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.049890 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.051837 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.052268 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.053987 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.055956 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.056537 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.057395 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.059397 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.060651 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.061220 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.063239 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.064061 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.067890 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.074988 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.077156 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.081729 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.108531 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.111231 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.115569 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.141589 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.144549 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.148905 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.173301 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.176790 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.180963 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.204073 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.207902 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.212126 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.231311 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.235234 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.239358 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.286182 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.290779 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.294410 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.931128 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.934165 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.938730 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.939863 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.941833 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.942944 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.943325 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.944908 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.947551 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.948077 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.949516 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.951386 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.952170 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.954152 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.954863 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.956935 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.958918 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.960333 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.961130 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.962276 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.963841 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.965266 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.965770 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.969310 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.970145 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.972066 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.973471 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.974344 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.976217 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.978008 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.978530 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.980294 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.982895 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.983532 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.984505 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.987493 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.989112 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.989336 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.993053 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.994673 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344677.998992 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.000533 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.003255 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.009360 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.013121 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.014566 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.016069 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.019357 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.020682 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.023157 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.026127 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.027438 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.033283 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.034594 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.035905 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.041410 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.047413 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.054276 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.060660 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.063180 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.065695 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.068673 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.071638 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.072273 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.074117 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.074840 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.076533 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.077325 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.079021 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.079524 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.080316 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.081556 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.082434 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.083314 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.084070 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.085815 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.087116 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.087219 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.088271 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.090219 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.091098 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.091296 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.092671 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.094220 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.095182 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.095563 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.098209 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.098822 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.101133 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.102799 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.105730 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.107349 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.109821 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.112449 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.114571 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.124455 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.128657 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.132210 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.140775 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.149040 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.162447 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.174835 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.183636 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.195613 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.208347 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.216761 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.217188 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.229420 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.231278 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.238538 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.243474 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.252744 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.253810 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.264936 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.275397 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.901971 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.904711 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.907704 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.910645 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.913914 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.916512 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.917143 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.919269 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.920383 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.922270 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.924062 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.925249 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.928054 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.928665 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.928687 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.931461 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.931950 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.932305 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.934490 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.935206 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.936773 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.937626 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.938902 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.940935 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.941435 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.942852 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.944203 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.946536 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.947012 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.947523 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.951254 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.951423 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.952431 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.955248 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.956104 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.959070 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.959593 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.961238 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.964161 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.966339 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.967155 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.968935 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.973768 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.974143 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.980123 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.980469 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.981061 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.986825 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.986921 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.994489 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.994506 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344678.995332 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.001609 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.009055 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.009155 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.009259 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.015387 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.021328 106366 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.022947 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.023635 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.035880 106377 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.037447 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.046828 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731344679.059847 106370 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 230ms/step - loss: 1.5590 - val_loss: 2.3061\n", + "Epoch 2/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:39.127002: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m15/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m0s\u001b[0m 45ms/step - loss: 1.7682" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:40.061810: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 1.7967 - val_loss: 2.3604\n", + "Epoch 3/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.7963 - val_loss: 2.3494\n", + "Epoch 4/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:41.537500: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 102ms/step - loss: 1.7203 - val_loss: 2.3561\n", + "Epoch 5/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 61ms/step - loss: 1.7349 - val_loss: 2.4006\n", + "Epoch 6/100\n", + "\u001b[1m15/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m0s\u001b[0m 44ms/step - loss: 1.8499" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:45.361657: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.8798 - val_loss: 2.3912\n", + "Epoch 7/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 1.7793 - val_loss: 2.3783\n", + "Epoch 8/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 101ms/step - loss: 1.7978 - val_loss: 2.3552\n", + "Epoch 9/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 60ms/step - loss: 1.7480 - val_loss: 2.3508\n", + "Epoch 10/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.8378 - val_loss: 2.3515\n", + "Epoch 11/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.0080 - val_loss: 2.3325\n", + "Epoch 12/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:04:52.137767: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 103ms/step - loss: 2.0942 - val_loss: 2.3436\n", + "Epoch 13/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 60ms/step - loss: 2.0440 - val_loss: 2.3832\n", + "Epoch 14/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.0942 - val_loss: 2.3229\n", + "Epoch 15/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.0860 - val_loss: 2.3367\n", + "Epoch 16/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.0992 - val_loss: 2.3287\n", + "Epoch 17/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.0887 - val_loss: 2.3275\n", + "Epoch 18/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1043 - val_loss: 2.3126\n", + "Epoch 19/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.0803 - val_loss: 2.3147\n", + "Epoch 20/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 101ms/step - loss: 2.1872 - val_loss: 2.3127\n", + "Epoch 21/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.2357 - val_loss: 2.2820\n", + "Epoch 22/100\n", + "\u001b[1m15/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m0s\u001b[0m 45ms/step - loss: 2.2433" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:05:06.568759: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.2414 - val_loss: 2.2913\n", + "Epoch 23/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.0625 - val_loss: 2.2656\n", + "Epoch 24/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 98ms/step - loss: 2.2639 - val_loss: 2.2524\n", + "Epoch 25/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.2612 - val_loss: 2.2844\n", + "Epoch 26/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.2705 - val_loss: 2.2789\n", + "Epoch 27/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1526 - val_loss: 2.2727\n", + "Epoch 28/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 98ms/step - loss: 2.2515 - val_loss: 2.2493\n", + "Epoch 29/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 2.2440 - val_loss: 2.2570\n", + "Epoch 30/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.0894 - val_loss: 2.2228\n", + "Epoch 31/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.2351 - val_loss: 2.1996\n", + "Epoch 32/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.0900 - val_loss: 2.2334\n", + "Epoch 33/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.2224 - val_loss: 2.2086\n", + "Epoch 34/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1015 - val_loss: 2.2045\n", + "Epoch 35/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.2142 - val_loss: 2.2007\n", + "Epoch 36/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 97ms/step - loss: 2.0611 - val_loss: 2.1690\n", + "Epoch 37/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.2040 - val_loss: 2.1692\n", + "Epoch 38/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 2.1956 - val_loss: 2.1815\n", + "Epoch 39/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1908 - val_loss: 2.2030\n", + "Epoch 40/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 102ms/step - loss: 2.1984 - val_loss: 2.1693\n", + "Epoch 41/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1951 - val_loss: 2.1845\n", + "Epoch 42/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.9823 - val_loss: 2.1958\n", + "Epoch 43/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9765 - val_loss: 2.1814\n", + "Epoch 44/100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:05:34.483472: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 97ms/step - loss: 2.1000 - val_loss: 2.1597\n", + "Epoch 45/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1804 - val_loss: 2.1576\n", + "Epoch 46/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1759 - val_loss: 2.1466\n", + "Epoch 47/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1689 - val_loss: 2.1498\n", + "Epoch 48/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 91ms/step - loss: 1.9566 - val_loss: 2.1511\n", + "Epoch 49/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9598 - val_loss: 2.1509\n", + "Epoch 50/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9598 - val_loss: 2.1570\n", + "Epoch 51/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 1.9635 - val_loss: 2.1548\n", + "Epoch 52/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 92ms/step - loss: 1.9644 - val_loss: 2.1494\n", + "Epoch 53/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 60ms/step - loss: 1.9602 - val_loss: 2.1599\n", + "Epoch 54/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9584 - val_loss: 2.1372\n", + "Epoch 55/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.0388 - val_loss: 2.1365\n", + "Epoch 56/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 82ms/step - loss: 2.1498 - val_loss: 2.1479\n", + "Epoch 57/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9569 - val_loss: 2.1332\n", + "Epoch 58/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1530 - val_loss: 2.1424\n", + "Epoch 59/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1529 - val_loss: 2.1472\n", + "Epoch 60/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 97ms/step - loss: 1.9496 - val_loss: 2.1263\n", + "Epoch 61/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.9690 - val_loss: 2.1322\n", + "Epoch 62/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1185 - val_loss: 2.1413\n", + "Epoch 63/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 1.9848 - val_loss: 2.1324\n", + "Epoch 64/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 91ms/step - loss: 1.9926 - val_loss: 2.1390\n", + "Epoch 65/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.9896 - val_loss: 2.1411\n", + "Epoch 66/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 1.9434 - val_loss: 2.1414\n", + "Epoch 67/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 1.9382 - val_loss: 2.1183\n", + "Epoch 68/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 102ms/step - loss: 1.9312 - val_loss: 2.1377\n", + "Epoch 69/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 1.9808 - val_loss: 2.1505\n", + "Epoch 70/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9460 - val_loss: 2.1340\n", + "Epoch 71/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1450 - val_loss: 2.1449\n", + "Epoch 72/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 1.9401 - val_loss: 2.1366\n", + "Epoch 73/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9378 - val_loss: 2.1495\n", + "Epoch 74/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9326 - val_loss: 2.1344\n", + "Epoch 75/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9310 - val_loss: 2.1381\n", + "Epoch 76/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 94ms/step - loss: 1.9268 - val_loss: 2.1261\n", + "Epoch 77/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 1.9204 - val_loss: 2.1328\n", + "Epoch 78/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.0092 - val_loss: 2.1338\n", + "Epoch 79/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1239 - val_loss: 2.1350\n", + "Epoch 80/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 97ms/step - loss: 1.9275 - val_loss: 2.1374\n", + "Epoch 81/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 61ms/step - loss: 2.0664 - val_loss: 2.1221\n", + "Epoch 82/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1249 - val_loss: 2.1244\n", + "Epoch 83/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1204 - val_loss: 2.1372\n", + "Epoch 84/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.1233 - val_loss: 2.1534\n", + "Epoch 85/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 61ms/step - loss: 2.1277 - val_loss: 2.1218\n", + "Epoch 86/100\n", + "\u001b[1m15/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m0s\u001b[0m 45ms/step - loss: 2.1163" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:06:31.088524: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 2.1172 - val_loss: 2.1345\n", + "Epoch 87/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1168 - val_loss: 2.1383\n", + "Epoch 88/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 98ms/step - loss: 2.1165 - val_loss: 2.1303\n", + "Epoch 89/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1197 - val_loss: 2.1393\n", + "Epoch 90/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1235 - val_loss: 2.1378\n", + "Epoch 91/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1154 - val_loss: 2.1450\n", + "Epoch 92/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.1172 - val_loss: 2.1414\n", + "Epoch 93/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 60ms/step - loss: 2.1172 - val_loss: 2.1324\n", + "Epoch 94/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 63ms/step - loss: 2.1195 - val_loss: 2.1508\n", + "Epoch 95/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 65ms/step - loss: 2.1240 - val_loss: 2.1442\n", + "Epoch 96/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 98ms/step - loss: 2.1248 - val_loss: 2.1292\n", + "Epoch 97/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1182 - val_loss: 2.1416\n", + "Epoch 98/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 62ms/step - loss: 2.1198 - val_loss: 2.1398\n", + "Epoch 99/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 64ms/step - loss: 2.1179 - val_loss: 2.1346\n", + "Epoch 100/100\n", + "\u001b[1m16/16\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 96ms/step - loss: 2.1156 - val_loss: 2.1439\n" + ] + } + ], + "source": [ + "\n", + "with strategy.scope():\n", + " # Build and compile the model\n", + " model_with_confidence= build_fixed_hits_model_with_confidence(input_shape=(tile_size, tile_size, 1), num_hits=max_hits_per_tile)\n", + " model_with_confidence.compile(optimizer='adam', loss=lambda y_true, y_pred: custom_loss_with_count_penalty(y_true, y_pred))\n", + "\n", + "\n", + " model_with_confidence.summary()\n", + "\n", + "# Train the model\n", + "history = model_with_confidence.fit(\n", + " train_dataset_prepared,\n", + " validation_data=val_dataset_prepared,\n", + " epochs=100, \n", + " verbose=1\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def aggregate_top_hits(tiles_predictions, num_hits=5, confidence_threshold=0.5):\n", + " # Combine predictions from all tiles in a single image\n", + " combined_predictions = np.concatenate(tiles_predictions, axis=0) # Shape: (num_tiles * num_hits, 3)\n", + " \n", + " # Filter predictions by confidence threshold\n", + " filtered_predictions = combined_predictions[combined_predictions[:, 2] >= confidence_threshold]\n", + " \n", + " # Sort filtered predictions by confidence score (3rd column)\n", + " sorted_predictions = filtered_predictions[filtered_predictions[:, 2].argsort()[::-1]] # Sort by confidence desc.\n", + " \n", + " # Select the top `num_hits` predictions based on confidence\n", + " top_hits = sorted_predictions[:num_hits, :2] # Keep only (x, y) coordinates of the top hits\n", + " \n", + " return top_hits\n", + "\n", + "\n", + "# Function to reconstruct the original image from tiles\n", + "def reconstruct_image(tiles, image_shape=(64, 64)):\n", + " tile_size = tiles.shape[1]\n", + " tiles_per_row = image_shape[1] // tile_size\n", + " tiles_per_col = image_shape[0] // tile_size\n", + " reconstructed = np.zeros(image_shape, dtype=tiles.dtype)\n", + " idx = 0\n", + " for i in range(tiles_per_col):\n", + " for j in range(tiles_per_row):\n", + " reconstructed[i*tile_size:(i+1)*tile_size, j*tile_size:(j+1)*tile_size] = tiles[idx]\n", + " idx += 1\n", + " return reconstructed\n", + "\n", + "def map_hits_to_image(image_idx, val_images, val_centroids, model, data_loader, num_tiles_per_side=4, confidence_threshold=0.5):\n", + " # Get the tiles and true centers for the specified image\n", + " tiles = val_images[image_idx] # Shape: (num_tiles, 16, 16)\n", + " true_centers = val_centroids[image_idx] # Shape: (num_tiles, 5, 2)\n", + "\n", + " num_tiles = tiles.shape[0]\n", + " tile_size = data_loader.tile_size\n", + "\n", + " # Collect predictions for each tile\n", + " tiles_predictions = []\n", + " for tile_idx, tile in enumerate(tiles):\n", + " tile_input = tile.reshape(1, tile_size, tile_size, 1).astype('float32')\n", + " tile_predictions = model.predict(tile_input)[0] # Shape: (num_hits, 3), with (x, y, confidence)\n", + " \n", + " # Apply confidence threshold to suppress low-confidence predictions\n", + " tile_predictions = tile_predictions[tile_predictions[:, 2] >= confidence_threshold]\n", + " \n", + " # Denormalize predictions within tile\n", + " tile_predictions[:, :2] *= tile_size\n", + " \n", + " # Adjust predictions to image-level coordinates\n", + " tile_row = tile_idx // num_tiles_per_side\n", + " tile_col = tile_idx % num_tiles_per_side\n", + " tile_predictions[:, 0] += tile_col * tile_size # x-coordinate\n", + " tile_predictions[:, 1] += tile_row * tile_size # y-coordinate\n", + " \n", + " tiles_predictions.append(tile_predictions)\n", + " \n", + " # Aggregate predictions across tiles to retain only the top 5 hits\n", + " top_5_hits = aggregate_top_hits(tiles_predictions, confidence_threshold=confidence_threshold)\n", + "\n", + " # Reconstruct the original image\n", + " reconstructed_image = reconstruct_image(tiles, image_shape=(tile_size*num_tiles_per_side, tile_size*num_tiles_per_side))\n", + "\n", + " # Initialize lists to hold image-level true and predicted hits\n", + " true_hits = []\n", + " for tile_idx in range(num_tiles):\n", + " tile_row = tile_idx // num_tiles_per_side\n", + " tile_col = tile_idx % num_tiles_per_side\n", + "\n", + " # True hits\n", + " for hit in true_centers[tile_idx]:\n", + " if not np.allclose(hit, [0.0, 0.0]):\n", + " img_x = tile_col * tile_size + hit[0] * tile_size\n", + " img_y = tile_row * tile_size + hit[1] * tile_size\n", + " true_hits.append((img_x, img_y))\n", + "\n", + " return reconstructed_image, true_hits, top_5_hits\n", + "\n", + "\n", + "# Visualization function to plot random images and their tiles with true and predicted hits\n", + "def visualize_random_predictions_with_tiles(val_images, val_centroids, model, data_loader, num_images_to_visualize=5, confidence_threshold=0.5):\n", + " num_tiles_per_side = data_loader.images.shape[1] // data_loader.tile_size # Assuming square images\n", + " total_images = len(val_images)\n", + " tile_size = data_loader.tile_size\n", + "\n", + " # Randomly select indices of images to visualize\n", + " random_indices = np.random.choice(total_images, num_images_to_visualize, replace=False)\n", + "\n", + " for img_idx in random_indices:\n", + " reconstructed_image, true_hits, pred_hits = map_hits_to_image(\n", + " img_idx, val_images, val_centroids, model, data_loader, num_tiles_per_side=num_tiles_per_side, confidence_threshold=confidence_threshold\n", + " )\n", + "\n", + " # Display the original image with predictions\n", + " plt.figure(figsize=(6, 6))\n", + " plt.imshow(reconstructed_image, cmap='gray')\n", + " plt.title(f'Image {img_idx} with True and Predicted Hits')\n", + " \n", + " # Plot true hits\n", + " if true_hits:\n", + " true_x, true_y = zip(*true_hits)\n", + " plt.scatter(true_x, true_y, c='green', marker='o', label='True Hits', alpha=0.6, s=50)\n", + "\n", + " # Plot predicted hits\n", + " if pred_hits.size > 0:\n", + " pred_x, pred_y = zip(*pred_hits)\n", + " plt.scatter(pred_x, pred_y, c='red', marker='x', label='Predicted Hits', alpha=0.6, s=50)\n", + "\n", + " plt.legend()\n", + " plt.xlabel('X-coordinate')\n", + " plt.ylabel('Y-coordinate')\n", + " plt.show()\n", + "\n", + " # Display tiles with predictions\n", + " tiles = val_images[img_idx]\n", + " num_tiles = len(tiles)\n", + " \n", + " fig, axs = plt.subplots(num_tiles_per_side, num_tiles_per_side, figsize=(10, 10))\n", + " fig.suptitle(f'Tiles for Image {img_idx}')\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " tile = tiles[tile_idx]\n", + " tile_input = tile.reshape(1, tile_size, tile_size, 1).astype('float32')\n", + " tile_predictions = model.predict(tile_input)[0] # Shape: (num_hits, 3), with (x, y, confidence)\n", + " \n", + " # Apply confidence threshold to suppress low-confidence predictions\n", + " tile_predictions = tile_predictions[tile_predictions[:, 2] >= confidence_threshold]\n", + " \n", + " # Denormalize tile predictions to tile coordinates\n", + " tile_predictions[:, :2] *= tile_size\n", + " \n", + " ax.imshow(tile, cmap='gray')\n", + " ax.set_title(f'Tile {tile_idx}')\n", + " ax.axis('off')\n", + " \n", + " # Plot true hits for this tile\n", + " true_tile_hits = val_centroids[img_idx][tile_idx]\n", + " for hit in true_tile_hits:\n", + " if not np.allclose(hit, [0.0, 0.0]):\n", + " ax.plot(hit[0] * tile_size, hit[1] * tile_size, 'go', markersize=5, label='True Hits')\n", + "\n", + " # Plot predicted hits for this tile\n", + " for pred in tile_predictions:\n", + " ax.plot(pred[0], pred[1], 'rx', markersize=5, label='Predicted Hits')\n", + " \n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.9)\n", + " plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 805ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-11 17:08:12.633152: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 134ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 142ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 134ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 148ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 142ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 823ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 152ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 141ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 825ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 140ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 134ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 139ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 145ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 143ms/step\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# Adjust the confidence threshold as desired, e.g., 0.5 or higher to suppress low-confidence predictions\n", + "visualize_random_predictions_with_tiles(val_images, val_midpoints, model_with_confidence, data_loader, num_images_to_visualize=2, confidence_threshold=0.55)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Instantiate DataLoader and process data\n", + "file_path = '/home/da886/Final Electron counting project/Images and Labels/80KFixed_Mixed_5_64by64_95indexNoNoise.h5'\n", + "data_loader = DataLoader(file_path, tile_size=16, max_hits_per_tile=5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3752483/1796227132.py:60: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.array(tiled_images), np.array(tiled_centers)\n" + ] + } + ], + "source": [ + "\n", + "\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "# Create TensorFlow datasets for training and validation\n", + "batch_size = 1000\n", + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", + "\n", + "train_dataset = train_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=True).batch(batch_size)\n", + "val_dataset = val_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=False).batch(batch_size)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0, 1.0, 0.9375, 0.9375)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(train_images), np.max(val_images), np.max(train_midpoints), np.max(val_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 0.0, 0.0, 0.0)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(train_images), np.min(val_images), np.min(train_midpoints), np.min(val_midpoints)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + " \n", + "# Function to visualize the tiles and hits, excluding (0, 0) padding values\n", + "def visualize_tiles(dataset, tile_size=16, image_count=1):\n", + " \"\"\"\n", + " Visualizes a specified number of tiled images from the TensorFlow dataset with hit locations.\n", + "\n", + " Parameters:\n", + " - dataset: tf.data.Dataset, the dataset to visualize (train or val)\n", + " - tile_size: int, the size of each tile\n", + " - image_count: int, the number of images to visualize from the dataset\n", + " \"\"\"\n", + " # Take one batch from the dataset\n", + " for images, centers in dataset.take(1):\n", + " images_np = images.numpy()\n", + " centers_np = centers.numpy()\n", + "\n", + " # Visualize up to `image_count` images\n", + " for img_idx in range(min(image_count, images_np.shape[0])):\n", + " num_tiles = images_np.shape[1]\n", + " grid_size = int(np.ceil(np.sqrt(num_tiles))) # Determine grid size dynamically\n", + " fig, axs = plt.subplots(grid_size, grid_size, figsize=(8, 8))\n", + " fig.suptitle(f\"Tiled Image with Electron Hits (Image {img_idx})\")\n", + "\n", + " for idx, ax in enumerate(axs.flat):\n", + " if idx < num_tiles:\n", + " ax.imshow(images_np[img_idx, idx], cmap='gray')\n", + " # Filter out (0, 0) padding values before plotting\n", + " for (x, y) in centers_np[img_idx, idx]:\n", + " if (x, y) != (0, 0): # Only plot valid hits\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='x', s=30)\n", + " ax.axis('off')\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAw0AAAMVCAYAAAA1ZBgWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoBUlEQVR4nO3dfbDVdZ3A8c+5oDwGBOITEg/qAuI6Ps0V2RDCNcLMVVEXM3zAwDYMtWlGJ2t8YDTNpTTNEm3LrhCr2DK5tbm4wspCSK7F6jC6NaAStpooWDxo3fvbP04c7unCh4tyvQ+8XjOM3N/53XO+59zfF8/7/B5uqSiKIgAAAHahprUHAAAAtG2iAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAdqBSy65JAYPHly1rFQqxQ033LDXHmPJkiVRKpViyZIle+0+9zU33HBDlEqlPVr39ddfb9Ex+bnumcGDB8cll1zS4o/T0NAQRx99dNx8880t/ljt1eTJk+P8889v7WEAfyYaoJWUSqVm/Wlrb/a+973vRalUiqeffrq1h9Iu3HLLLbFw4cK9fr+XXHLJLreZrl277vXH25XVq1fHDTfcEC+++OL79pjNtbttddy4cXH00Uen99FSz+8HP/hBrFu3Lq644orKsn1pbn3nO9+JESNGRNeuXePII4+Mu+66q8k611xzTTzyyCOxatWqVhgh8Jc6t/YAYF9VV1dX9fX3v//9WLRoUZPlI0aMiPvuuy8aGhrez+HxLnzpS1+Ka6+9tmrZLbfcEueee26cddZZe/3xunTpEvfff3+T5Z06ddrrj7Urq1evjhtvvDHGjRvXZG9Ye/TCCy9ETc2Oz9Na6vndfvvtMXny5Ojdu/deu8/24t57743PfOYzMWnSpPj85z8fS5cujZkzZ8aWLVvimmuuqax33HHHxYknnhizZ8+O73//+604YiBCNECr+dSnPlX19YoVK2LRokVNltN+dO7cOTp3fv/+We3cuXO72l6Kooht27ZFt27dWnsou9SlS5cWf4xf/OIXsWrVqpg9e3aLP1Zbs3Xr1rjuuuvi4x//eCxYsCAiIqZNmxYNDQ0xa9asmD59enzwgx+srH/++efH9ddfH/fcc0/07NmztYYNhMOToF3Y2TkNO7N+/fqYOnVqHHTQQdGlS5cYOXJk/NM//VOT9X7zm9/EWWedFT169IgDDzwwrr766nj77bff0/h69uwZL7/8cpxxxhnRs2fPGDBgQHzzm9+MiIhnn302xo8fHz169IhBgwbFvHnzqr7/jTfeiC984Qvx13/919GzZ8/o1atXTJw4caeHJbz00ktx5plnVo39scce2+mhXE899VR87GMfi969e0f37t1j7NixsWzZsvS5FEURBxxwQHz+85+vLGtoaIg+ffpEp06dYuPGjZXlt912W3Tu3Dn+8Ic/RETTcxpKpVJs3rw5HnjggcqhQ395vPzGjRvjkksuiT59+kTv3r3j0ksvjS1btqRj3Bua+9qsX78+Lrvssjj00EOjS5cuMWTIkPiHf/iHeOedd+J73/tenHfeeRER8ZGPfKTJIXWDBw+OM844Ix577LE48cQTo1u3bnHvvfdGRMSaNWvivPPOi759+0b37t1j1KhR8eMf/7jqsbefj/HQQw/FzTffHIcddlh07do1Tj311Pj1r3/dIq9L43Madvf8nn766ZgwYUIccMAB0a1btxgyZEhMnTp1t4+xcOHC2H///eOUU07Z7bodaW5FRCxevDg2bNgQn/3sZ6uWz5gxIzZv3txkGzjttNNi8+bNsWjRot3eN9Cy7GmADuLVV1+NUaNGRalUiiuuuCL69+8f//Zv/xaXXXZZvPXWW3HVVVdFRPmTvlNPPTVefvnlmDlzZhx66KFRV1cXTzzxxHt6/Pr6+pg4cWKccsop8dWvfjXmzp0bV1xxRfTo0SOuu+66uPDCC+Occ86Jb3/723HRRRfFySefHEOGDImI8hvIhQsXxnnnnRdDhgyJV199Ne69994YO3ZsrF69Og499NCIiNi8eXOMHz8+fvvb38aVV14ZBx98cMybNy8WL17cZDxPPPFETJw4MU444YS4/vrro6amJr773e/G+PHjY+nSpVFbW7vT51EqleJv/uZv4sknn6ws+5//+Z/YtGlT1NTUxLJly+LjH/94REQsXbo0jjvuuF1+AlpXVxef/vSno7a2NqZPnx4REYcffnjVOueff34MGTIkvvKVr8QzzzwT999/fxx44IFx2223Net139mJ1Pvvv3/06tVrl9/T3NfmlVdeidra2ti4cWNMnz49hg8fHuvXr48FCxbEli1b4pRTTomZM2fGN77xjfjiF78YI0aMiIio/DeifLjPBRdcEJdffnlMmzYthg0bFq+++mqMHj06tmzZEjNnzox+/frFAw88EGeeeWYsWLAgzj777Krx3nrrrVFTUxNf+MIXYtOmTfHVr341Lrzwwnjqqaea9Rpt2rRpp6/TH//4x/T7suf32muvxUc/+tHo379/XHvttdGnT5948cUX44c//OFux7N8+fI4+uijY7/99mvW+DvK3Ioo72WJiDjxxBOrlp9wwglRU1MTv/jFL6r2nh111FHRrVu3WLZsWZPtAnifFUCbMGPGjGJXU/Liiy8uBg0aVLUsIorrr7++8vVll11WHHLIIcXrr79etd7kyZOL3r17F1u2bCmKoijuuOOOIiKKhx56qLLO5s2biyOOOKKIiGLx4sXpOL/73e8WEVH8/Oc/rxpfRBS33HJLZdmbb75ZdOvWrSiVSsX8+fMry59//vkmY9+2bVtRX19f9Thr164tunTpUtx0002VZbNnzy4ioli4cGFl2datW4vhw4dXjb2hoaE48sgjiwkTJhQNDQ2Vdbds2VIMGTKkOO2009LnePvttxedOnUq3nrrraIoiuIb3/hGMWjQoKK2tra45ppriqIoivr6+qJPnz7F1VdfXfm+66+/vsnPsEePHsXFF1/c5DG2rzt16tSq5WeffXbRr1+/dHxFseM139mfCRMmVNZbvHjxu35tLrrooqKmpqbqZ73d9u99+OGHd7ndDBo0qIiI4qc//WnV8quuuqqIiGLp0qWVZb///e+LIUOGFIMHD65sC9vHPmLEiOLtt9+urHvnnXcWEVE8++yz6Wu0fVvN/owcObLJmBv/vHb1/P7lX/6lyTxorsMOO6yYNGnSLsfbkefWjBkzik6dOu30tv79+xeTJ09usvyv/uqviokTJ6b3C7Q8hydBB1AURTzyyCPxiU98IoqiiNdff73yZ8KECbFp06Z45plnIiLiJz/5SRxyyCFx7rnnVr6/e/fulU/C34tPf/rTlb/36dMnhg0bFj169Ki6bOKwYcOiT58+sWbNmsqyLl26VE4+ra+vjw0bNkTPnj1j2LBhlXFHRPz0pz+NAQMGxJlnnllZ1rVr15g2bVrVOH75y1/Gr371q/jkJz8ZGzZsqLwWmzdvjlNPPTWefPLJ9MTyMWPGRH19fSxfvjwiynsUxowZE2PGjImlS5dGRMRzzz0XGzdujDFjxrybl6riM5/5TJPH3rBhQ7z11lu7/d6uXbvGokWLmvy59dZbd/k9zX1tGhoaYuHChfGJT3yiyafCEdHsS8sOGTIkJkyYULXsJz/5SdTW1saHP/zhyrKePXvG9OnT48UXX4zVq1dXrX/ppZfG/vvvX/l6+2veeBvKfPOb39zp63TMMcc06/t3pk+fPhER8a//+q+73WPxlzZs2FB13H5zdJS5tXXr1qqfZWNdu3aNrVu3Nln+wQ9+sMUvTQzsnsOToAP43e9+Fxs3bow5c+bEnDlzdrrOa6+9FhHl45aPOOKIJm/6hg0b9p7G0LVr1+jfv3/Vst69e8dhhx3W5LF69+4db775ZuXrhoaGuPPOO+Oee+6JtWvXRn19feW2fv36Vf7+0ksvxeGHH97k/o444oiqr3/1q19FRMTFF1+8y/Fu2rRpl2/cjj/++OjevXssXbo0JkyYEEuXLo0bb7wxDj744Ljrrrti27ZtlXho/Mb33fjQhz5U9fX2Mb355pvpIUYR5ask/e3f/u0ePV5zX5t33nkn3nrrrd1eknR3th8m09hLL70UJ510UpPl2w//eemll6oeN3uNmqO2tnan4fNe3oyOHTs2Jk2aFDfeeGN8/etfj3HjxsVZZ50Vn/zkJ5t1MnVRFM1+rI40t7p16xbvvPPOTm/b1UnyRVE0O1KBliMaoAPY/snepz71qV3+z/y9fKraHLu6zOeuljd+03TLLbfEl7/85Zg6dWrMmjUr+vbtGzU1NXHVVVe9q0vNbv+e22+/PY499tidrpNdiWW//faLk046KZ588sn49a9/Hf/3f/8XY8aMiYMOOij++Mc/xlNPPRVLly6N4cOHN3kzt6ea8/rsTc19bd5444298nh740pJ7/dr1BylUikWLFgQK1asiEcffTQee+yxmDp1asyePTtWrFiRbl/9+vVrdvBEdKy5dcghh0R9fX289tprceCBB1aWv/POO7Fhw4bKORaNvfnmm3HkkUfu8ViBvUs0QAfQv3//+MAHPhD19fW7/eR50KBB8dxzzzX59O6FF15o6WHu0oIFC+IjH/lIfOc736lavnHjxjjggAMqXw8aNChWr17dZOx/eSWd7Scb9+rVa48/id9uzJgxcdttt8Xjjz8eBxxwQAwfPjxKpVKMHDkyli5dGkuXLo0zzjhjt/fT1j4hbe5r079//+jVq1c899xz6f29m+c3aNCgnW5vzz//fOX2tmJ3z2/UqFExatSouPnmm2PevHlx4YUXxvz586sOJ/pLw4cPj7Vr1+7toe5UW5tb20Pj6aefjtNPP72y/Omnn46GhoYmIfKnP/0p1q1bV3XYFNA6nNMAHUCnTp1i0qRJ8cgjj+z0Td7vfve7yt9PP/30eOWVVyrXSI+I2LJlyy4Pa3o/dOrUqcmnxg8//HCsX7++atmECRNi/fr18aMf/aiybNu2bXHfffdVrXfCCSfE4YcfHv/4j/9YuRxqY41fj10ZM2ZMvP3223HHHXfEhz/84cobqTFjxkRdXV288sorzTqfoUePHlWXaW1tzX1tampq4qyzzopHH310p7+hePvPq0ePHhERe/QcTz/99Fi5cmX87Gc/qyzbvHlzzJkzJwYPHhxHHXXUnjylFrWr5/fmm2822Wa3v+Hd3eWLTz755Hjuuefe02WOm6utza3x48dH375941vf+lbV8m9961vRvXv3ypXJtlu9enVs27YtRo8end4v0PLsaYAO4tZbb43FixfHSSedFNOmTYujjjoq3njjjXjmmWfi8ccfrxxuMm3atLj77rvjoosuiv/+7/+OQw45JOrq6qJ79+6tNvYzzjgjbrrpprj00ktj9OjR8eyzz8bcuXNj6NChVetdfvnlcffdd8cFF1wQV155ZRxyyCExd+7c6Nq1a0Ts+FS4pqYm7r///pg4cWKMHDkyLr300hgwYECsX78+Fi9eHL169YpHH300HdPJJ58cnTt3jhdeeKHqJPFTTjml8oanOdFwwgknxOOPPx5f+9rX4tBDD40hQ4bs9Hj+d+NPf/pTPPjggzu97eyzz6684W1sT16bW265Jf793/89xo4dG9OnT48RI0bEb3/723j44Yfjv/7rv6JPnz5x7LHHRqdOneK2226LTZs2RZcuXWL8+PFVh578pWuvvTZ+8IMfxMSJE2PmzJnRt2/feOCBB2Lt2rXxyCOPVP1G5ta2q+c3b968uOeee+Lss8+Oww8/PH7/+9/HfffdF7169ar6BH1n/u7v/i5mzZoV//mf/xkf/ehHW3T8bW1udevWLWbNmhUzZsyI8847r3LO0IMPPhg333xz9O3bt2r9RYsWRffu3eO0007by68MsKdEA3QQBx10UKxcuTJuuumm+OEPfxj33HNP9OvXL0aOHFl1zf/u3bvHf/zHf8TnPve5uOuuu6J79+5x4YUXxsSJE+NjH/tYq4z9i1/8YmzevDnmzZsX//zP/xzHH398/PjHP45rr722ar2ePXvGE088EZ/73OfizjvvjJ49e8ZFF10Uo0ePjkmTJlXe4EREjBs3Ln72s5/FrFmz4u67744//OEPcfDBB8dJJ50Ul19++W7H1KNHjzjuuOPi5z//edXJzttDYeDAgc06jOZrX/taTJ8+Pb70pS/F1q1b4+KLL95r0fD222/HlClTdnrb2rVrdxoNEc1/bQYMGBBPPfVUfPnLX465c+fGW2+9FQMGDIiJEydWIvPggw+Ob3/72/GVr3wlLrvssqivr4/Fixen0XDQQQfF8uXL45prrqmcWH7MMcfEo48+2uST5ta2q+c3duzYWLlyZcyfPz9effXV6N27d9TW1sbcuXN3evJ3YyeccEIcc8wx8dBDD7V4NLTFufXZz3429ttvv5g9e3b86Ec/ioEDB8bXv/71uPLKK5us+/DDD8c555wTH/jAB977iwG8J6WiNc8kA9gL7rjjjrj66qvjN7/5TQwYMKC1hwO7VVdXFzNmzIiXX365cvnWtqg159Yvf/nLOP744+OZZ57Z5UnXwPtHNADtytatW6uuyLNt27Y47rjjor6+Pv73f/+3FUcGzdfQ0BDHHHNMXHDBBXHddde19nAiou3NrcmTJ0dDQ0M89NBD7/tjA005PAloV84555z40Ic+FMcee2xs2rQpHnzwwXj++edj7ty5rT00aLaamprdXpnq/dbW5tb8+fNb5XGBnRMNQLsyYcKEuP/++2Pu3LlRX18fRx11VMyfPz/+/u//vrWHBu2auQVkHJ4EAACk2s517QAAgDZJNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAECqc3NXLJVKLTkO2OuKomix+zYfaG/MB6jWUnPCfKC9ae5csKcBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqWiKIrWHgQAANB22dMAAACkRAMAAJASDQAAQEo0AAAAKdEAAACkRAMAAJASDQAAQEo0AAAAKdEAAACkRAMAAJASDQAAQEo0AAAAKdEAAACkRAMAAJDq3NwVS6VSS44D9rqiKFrsvs0H2hvzAaq11JwwH2hvmjsX7GkAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAVOfWHgDQ8RVFsf0vEaXSzlaIKJWitLPbAIBWZ08D8P5YtSpi1KiIdeuql69bV16+alXrjAsA2K1SUfkIcDcr+gSQdqaZm/a7Yj7smaKhoRwGK1dGDB0asWRJxMCB5WAYNy5izZqI2toorVzZ2kPtsMwHqNZSc8J8oL1p7lywpwFoeaVSxIIF5WBYs6YcCsuX7wiGoUPLtwMAbZI9DXRYPlltOyo/i8Z7FrZrtOfB69pyzAeoZk8DlNnTALQ9AwdG1NVVL6urKy8HANos0QC8f9ati5gypXrZlClNT44GANoU0QC8PxofmjR0aMSyZdXnOAgHAGiznNNAh+UY7rbD1ZNan/kA1ZzTAGXOaQDajlIpYs6ciNraHcEQUf7vkiXl5XPmtOYIAYCEPQ10WD5ZbTv8RujWZz5ANXsaoKy5c6FzC48DwP9EAaCdc3gSAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQ8huhafavD4/wm30BAPZF9jSww67iYQ+iAgCAjkc0ULZqVcSoURHr1lUvX7euvHzVqtYZFwAAra5UNPPYFIeldFxFQ0M5DFaujBg6NGLJkoiBA8vBMG5cxJo1EbW1EStWRKmm/XTmnhx2tafMB9ob8wGqtdScMB9ob5o7F9rPO0BaTqkUsWBBORjWrCmHwvLlO4Jh6NDy7f4hBADYJ9nTwI7CbLxnYbvGex6ifW0HPlmFHcwHqGZPA5TZ08CeGzgwoq6uelldXSUYAADYN4kGdli3LmLKlOplU6Y0PTkaAIB9imigrPGhSUOHRixbVn2Og3AAANhniQbKv4fh3HN3BMOSJRGjR5f/uz0czj3X72sAANhHiQbKV0WaM6d8WdVGJz3HwIHlr2try7c7uQsAYJ/k6kl0WK4WAzuYD1DN1ZOgzNWTAACAvUI0AAAAKdEAAACkRAMAAJASDQAAQEo0AAAAKdEAAACkRAMAAJASDQAAQEo0AAAAKdEAAACkRAMAAJASDQAAQEo0AAAAKdEAAACkRAMAAJASDQAAQEo0AAAAKdEAAACkRAMAAJASDQAAQKpzaw8AAHh/FUWx/S8RpdLOVqgsL+3sdmCfY08DAOyLVq2KGDUqYt266uXr1pWXr1rVOuMC2qRSUfm4YTcr+qSBdqaZm/a7Yj7Q3pgPNFY0NJTDYOXKiKFDI5YsiRg4sBwM48ZFrFkTUVsbsWJFlGo65ueLLTUnzAfam+bOhY75LwEAsGulUsSCBeVgWLOmHArLl+8IhqFDy7d7Awz8mT0NdFg+WYUdzAcaq2wPjfcsbNd4z0N03J+vPQ1QZk8DAJAbODCirq56WV1dJRgAthMNALCvWrcuYsqU6mVTpjQ9ORrY54kGANgXNT40aejQiGXLqs9xEA5AI6IBAPY1RRFx7rk7gmHJkojRo8v/3R4O555bXg8gRAMA7HtKpYg5c8qXVW100nMMHFj+ura2fLuTeoE/c/UkOixXi4EdzAca8xuhXT0JtmvuXOjcwuMAANoYb2yBPeXwJAAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAlGgAAABSogEAAEiJBgAAICUaAACAVKkoiqK1BwEAALRd9jQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKQ6N3fFUqnUkuOAFlEURYvcr/lAe2Q+wA7mA5Q1dy7Y0wAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKREAwAAkBINAABASjQAAAAp0QAAAKQ6t/YAaBuKomjWeqVSqYVHQkfU3O0rwjYGAG2RPQ3ssKs3dnvwhg9StjEAaJdEA2WrVkWMGhWxbl318nXrystXrWqdcdFx2MYAoN0qFc08bsAhAx1bUVsbsXJlxNChEUuWRAwcWH4zN25cxJo1EbW1EStWRKmmfXXmnhwWsyfMhz1TNDSUw6ADbmPtifkAO5gPUNbcueD/zpQtWFB+M7dmTflN3PLlO97MDR1avt0/hLxbpZJtDADaMXsaiIg/V2bjT323a/ypcLS/7cAnSW1D5efQAbex9sR8gB3MByizp4E9N3BgRF1d9bK6usqbOXjPbGMA0C6JBnZYty5iypTqZVOmND1xFd4t2xgAtEuigbLGh40MHRqxbFn18efe1PFe2cYAoN1yTgMR4epJe8p82DOuntQ2mA+wg/kAZc5pYM/MmVN+09bohNQYOLD8dW1t+Xb/EPJulUq2MQBox+xpoEPzSRLsYD7ADuYDlNnTAAAA7BWiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgJRoAAICUaAAAAFKiAQAASIkGAAAgVSqKomjtQQAAAG2XPQ0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAAKnOzV2xVCq15DigRRRF0SL3az7QHpkPsIP5AGXNnQv2NAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAEBKNAAAACnRAAAApEQDAACQEg0AAECqVBRF0dqDAAAA2i57GgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgJRoAAAAUqIBAABIiQYAACAlGgAAgNT/A5/W+la7O8PgAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage:\n", + "# Visualize only 1 or 2 images from the training dataset, excluding (0, 0) padding\n", + "visualize_tiles(train_dataset, tile_size=16, image_count=2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from tensorflow.keras import layers, Model\n", + "\n", + "def build_fixed_hits_model(input_shape=(16, 16, 1), num_hits=5):\n", + " output_units = num_hits * 2 # 2 coordinates (x, y) for each hit\n", + "\n", + " inputs = layers.Input(shape=input_shape)\n", + " \n", + " # Convolutional layers\n", + " x = layers.Conv2D(128, (5, 5), activation='relu', padding='same')(inputs)\n", + " x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)\n", + " x = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(x)\n", + " \n", + " x = layers.MaxPooling2D((2, 2))(x)\n", + "\n", + " # Fully connected layers\n", + " x = layers.Flatten()(x)\n", + " x = layers.Dense(64, activation='relu')(x)\n", + "\n", + " # Output layer with exactly 5 (x, y) pairs\n", + " coordinates_output = layers.Dense(output_units, activation='sigmoid', name='coordinates_output')(x)\n", + " coordinates_output_reshaped = layers.Reshape((num_hits, 2), name='coordinates_output_reshaped')(coordinates_output)\n", + "\n", + " model = Model(inputs, coordinates_output_reshaped)\n", + " return model\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot sample tiles and hit locations\n", + "v = np.random.randint(0, len(data_loader.images))\n", + "tiles, hits_per_tile = data_loader.map_hits_to_tiles(data_loader.images[v], data_loader.centers[v])\n", + "\n", + "fig, axs = plt.subplots(4, 4, figsize=(12, 12))\n", + "for i, ax in enumerate(axs.flat):\n", + " tile = tiles[i]\n", + " hits = hits_per_tile[i]\n", + " \n", + " ax.imshow(tile, cmap='gray')\n", + " for (x, y) in hits:\n", + " ax.scatter(x, y, c='red', marker='x')\n", + " ax.axis('on')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# @tf.keras.utils.register_keras_serializable()\n", + "# def euclidean_sorted_custom_loss(exponent=2):\n", + "# def sort_midpoints_by_distance(midpoints, reference_point=(0.0, 0.0)):\n", + "# # Reshape reference_point to match the shape of midpoints for broadcasting\n", + "# reference_point = tf.constant(reference_point, dtype=midpoints.dtype)\n", + "# reference_point = tf.reshape(reference_point, (1, 1, 2)) # Shape (1, 1, 2)\n", + " \n", + "# # Reshape midpoints to (batch_size, num_hits, 2) for sorting\n", + "# midpoints = tf.reshape(midpoints, (-1, 5, 2)) # Assuming 5 hits per image\n", + " \n", + "# # Calculate Euclidean distances from the reference point\n", + "# distances = tf.norm(midpoints - reference_point, axis=-1) # Shape: (batch_size, num_hits)\n", + " \n", + "# # Get sorted indices based on distances\n", + "# sorted_indices = tf.argsort(distances, axis=1)\n", + " \n", + "# # Gather sorted midpoints\n", + "# sorted_midpoints = tf.gather(midpoints, sorted_indices, batch_dims=1)\n", + "# return sorted_midpoints\n", + " \n", + "# def loss(y_true, y_pred):\n", + "# # Define the reference point\n", + "# reference_point = (0.0, 0.0)\n", + " \n", + "# # Sort both y_true and y_pred based on distances from the reference point\n", + "# y_true_sorted = sort_midpoints_by_distance(y_true, reference_point)\n", + "# y_pred_sorted = sort_midpoints_by_distance(y_pred, reference_point)\n", + " \n", + "# # Calculate Euclidean distance between sorted true and predicted midpoints\n", + "# diff = tf.abs(y_true_sorted - y_pred_sorted)\n", + "# powered_diff = tf.pow(diff, exponent)\n", + " \n", + "# # Return the mean loss across all coordinates\n", + "# return tf.reduce_mean(powered_diff)\n", + " \n", + "# return loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 16, 16, 1)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 16, 16, 128)    │         3,328 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 16, 16, 64)     │        73,792 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 16, 16, 128)    │        73,856 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 8, 8, 128)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 8192)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 64)             │       524,352 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ coordinates_output (Dense)      │ (None, 10)             │           650 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ coordinates_output_reshaped     │ (None, 5, 2)           │             0 │\n",
+       "│ (Reshape)                       │                        │               │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m3,328\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m73,792\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8192\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m524,352\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ coordinates_output (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m650\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ coordinates_output_reshaped │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 675,978 (2.58 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m675,978\u001b[0m (2.58 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 675,978 (2.58 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m675,978\u001b[0m (2.58 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with strategy.scope():\n", + " # Rebuild the model with the corrected input shape\n", + " model = build_fixed_hits_model(input_shape=(16, 16, 1), num_hits=5)\n", + "\n", + " # Compile the model\n", + " model.compile(optimizer='adam', loss='mse')\n", + "\n", + " # Display the model summary\n", + " model.summary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<_BatchDataset element_spec=(TensorSpec(shape=(None, 16, 16, 16), dtype=tf.float64, name=None), TensorSpec(shape=(None, 16, 5, 2), dtype=tf.float64, name=None))>" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "INFO:tensorflow:Error reported to Coordinator: Exception encountered when calling Functional.call().\n", + "\n", + "\u001b[1mInput 0 of layer \"conv2d\" is incompatible with the layer: expected axis -1 of input shape to have value 1, but received input with shape (None, 16, 16, 16)\u001b[0m\n", + "\n", + "Arguments received by Functional.call():\n", + " • inputs=tf.Tensor(shape=(None, 16, 16, 16), dtype=float64)\n", + " • training=True\n", + " • mask=None\n", + "Traceback (most recent call last):\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/training/coordinator.py\", line 293, in stop_on_exception\n", + " yield\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/distribute/mirrored_run.py\", line 387, in run\n", + " self.main_result = self.main_fn(*self.main_args, **self.main_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/tensorflow/python/autograph/impl/api.py\", line 643, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data\n", + " return self.train_step(data)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 51, in train_step\n", + " y_pred = self(x, training=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py\", line 122, in error_handler\n", + " raise e.with_traceback(filtered_tb) from None\n", + " File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/input_spec.py\", line 227, in assert_input_compatibility\n", + " raise ValueError(\n", + "ValueError: Exception encountered when calling Functional.call().\n", + "\n", + "\u001b[1mInput 0 of layer \"conv2d\" is incompatible with the layer: expected axis -1 of input shape to have value 1, but received input with shape (None, 16, 16, 16)\u001b[0m\n", + "\n", + "Arguments received by Functional.call():\n", + " • inputs=tf.Tensor(shape=(None, 16, 16, 16), dtype=float64)\n", + " • training=True\n", + " • mask=None\n" + ] + }, + { + "ename": "ValueError", + "evalue": "in user code:\n\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data **\n return self.train_step(data)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 51, in train_step\n y_pred = self(x, training=True)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py\", line 122, in error_handler\n raise e.with_traceback(filtered_tb) from None\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/input_spec.py\", line 227, in assert_input_compatibility\n raise ValueError(\n\n ValueError: Exception encountered when calling Functional.call().\n \n \u001b[1mInput 0 of layer \"conv2d\" is incompatible with the layer: expected axis -1 of input shape to have value 1, but received input with shape (None, 16, 16, 16)\u001b[0m\n \n Arguments received by Functional.call():\n • inputs=tf.Tensor(shape=(None, 16, 16, 16), dtype=float64)\n • training=True\n • mask=None\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[9], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Train the model with the flattened dataset\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[43m \u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\n\u001b[1;32m 7\u001b[0m \u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py:122\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 119\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m 120\u001b[0m \u001b[38;5;66;03m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m 121\u001b[0m \u001b[38;5;66;03m# `keras.config.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m--> 122\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 123\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m/tmp/__autograph_generated_file7tzs3j2_.py:14\u001b[0m, in \u001b[0;36mouter_factory..inner_factory..tf__wrapped_fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 13\u001b[0m do_return \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m retval_ \u001b[38;5;241m=\u001b[39m ag__\u001b[38;5;241m.\u001b[39mconverted_call(ag__\u001b[38;5;241m.\u001b[39mld(call_for_each_replica), (ag__\u001b[38;5;241m.\u001b[39mld(strategy), ag__\u001b[38;5;241m.\u001b[39mld(fn)\u001b[38;5;241m.\u001b[39mpython_function, ag__\u001b[38;5;241m.\u001b[39mld(args), ag__\u001b[38;5;241m.\u001b[39mld(kwargs)), \u001b[38;5;28;01mNone\u001b[39;00m, fscope)\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m:\n\u001b[1;32m 16\u001b[0m do_return \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "\u001b[0;31mValueError\u001b[0m: in user code:\n\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 108, in one_step_on_data **\n return self.train_step(data)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py\", line 51, in train_step\n y_pred = self(x, training=True)\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py\", line 122, in error_handler\n raise e.with_traceback(filtered_tb) from None\n File \"/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/layers/input_spec.py\", line 227, in assert_input_compatibility\n raise ValueError(\n\n ValueError: Exception encountered when calling Functional.call().\n \n \u001b[1mInput 0 of layer \"conv2d\" is incompatible with the layer: expected axis -1 of input shape to have value 1, but received input with shape (None, 16, 16, 16)\u001b[0m\n \n Arguments received by Functional.call():\n • inputs=tf.Tensor(shape=(None, 16, 16, 16), dtype=float64)\n • training=True\n • mask=None\n" + ] + } + ], + "source": [ + "# Train the model with the flattened dataset\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=val_dataset,\n", + " epochs=10, \n", + " verbose=1\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_training_history(history):\n", + " \"\"\"\n", + " Plots the training and validation losses against epochs in a log scale,\n", + " and the loss against the learning rate.\n", + "\n", + " Parameters:\n", + " - history: History object returned by model.fit, containing training metrics.\n", + " \"\"\"\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot training and validation loss on a log scale\n", + " plt.figure(figsize=(14, 6))\n", + " \n", + " # Loss plot (log scale)\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history.history['loss'], label='Training Loss')\n", + " plt.plot(epochs, history.history['val_loss'], label='Validation Loss')\n", + " plt.yscale('log') # Logarithmic scale for loss\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss (log scale)')\n", + " plt.title('Training and Validation Loss (Log Scale)')\n", + " plt.legend()\n", + "\n", + " \n", + "# Example usage after training\n", + "plot_training_history(history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/10\u001b[0m \u001b[32m━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4s\u001b[0m 466ms/step" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1731270681.864030 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.864879 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.865243 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.865628 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.866005 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.866358 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.866752 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.867180 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.867587 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.868007 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.868523 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.869511 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.869509 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870075 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870153 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870477 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870840 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.870967 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.871524 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.871767 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.871845 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.872080 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.872285 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.872690 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873004 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873070 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873276 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873529 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.873818 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.874201 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.874428 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.874599 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.874782 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.875140 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.875579 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.875640 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.875913 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.876087 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.876928 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.876937 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.877096 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.877840 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.878114 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.878253 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.878699 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.879116 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.879671 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.879950 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.880484 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.881018 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.881550 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.881973 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.882506 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.882959 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.883480 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.884155 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.884664 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.889943 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.890426 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.890898 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.891332 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.891810 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.892300 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.892714 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.893188 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.893749 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.894433 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.895170 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.895844 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.895974 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.896515 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.896609 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.897090 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.897239 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.897319 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.897864 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.898050 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.898221 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.898517 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.898633 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.899288 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.899302 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.899885 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.899963 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.900522 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.900593 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.901066 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.901254 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.901640 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.901944 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.902339 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.902684 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.903073 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.903401 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.903779 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.904307 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.904683 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.905241 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.905620 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.911763 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.912303 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.912773 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.913246 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.913712 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.914134 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.914621 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.915012 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.915424 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.916018 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.916555 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.917618 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.918684 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.918900 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.919372 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.919448 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.919883 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.920115 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.920341 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.920738 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.920972 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.921069 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.921234 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.921489 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.921674 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922001 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922163 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922406 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922649 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.922834 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.923246 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.923400 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.923526 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.923695 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.924088 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.924404 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.924502 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.924974 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.925179 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.926067 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.926321 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.926431 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.927139 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.928289 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.928463 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.929211 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.930657 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.931404 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.931728 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.932473 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.933609 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.934349 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.935444 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.936184 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.961099 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.961511 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.961981 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.962438 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.962895 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.963295 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.963842 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.964300 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.964741 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.965192 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.965657 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.966190 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.966716 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.967279 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.967854 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.968587 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.968869 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.969053 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.969361 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.969539 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.969791 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.970161 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.970365 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.970437 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.970965 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.971043 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.971648 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.971716 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.972188 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.972291 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.972873 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.972942 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.973462 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.973531 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.974047 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.974135 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.974562 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.974668 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.975077 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.975247 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.975647 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.975811 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.976197 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.976396 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.976761 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.976994 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.977352 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.977605 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.978215 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.978338 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.978434 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.978725 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.979127 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.979487 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.979736 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.979815 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.980200 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.980632 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.981128 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.981483 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.981932 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.982346 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.982796 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.983871 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.984911 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.986835 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.986993 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.987324 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.987421 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.987853 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.987927 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.988254 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.988423 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.988797 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989137 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989153 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989269 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989581 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.989762 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990001 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990172 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990791 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990858 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.990868 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.991293 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.991371 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.991892 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.991962 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.992340 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.992508 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.992525 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.993091 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.993161 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.993964 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.994316 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.994393 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.995510 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.995580 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.997580 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.997656 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.999702 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270681.999770 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.001175 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.001246 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.002658 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.002727 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.004411 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.004487 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.026895 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.027285 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.027674 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.028063 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.028466 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.028852 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.029248 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.029663 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.030079 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.030524 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.030978 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.031445 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.031924 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.032458 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.033017 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.033615 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.034690 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.035225 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.036295 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.036894 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.037358 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.037552 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038152 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038225 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038240 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038688 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.038764 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039365 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039380 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039398 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039918 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.039995 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.040477 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.040694 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.040718 3737177 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.040919 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.041113 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.041395 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.041560 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.042235 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.042367 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.042739 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.042906 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.043247 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.043418 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.043769 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.043936 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.044302 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.044466 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.044874 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.045041 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.045476 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.045642 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.046127 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.046290 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.047254 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.047421 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.047846 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.048007 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.048950 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.049126 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.049608 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.049775 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.050605 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.050776 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.051489 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.051655 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.052662 3737172 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1731270682.052831 3737214 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m10/10\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 9ms/step \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-11-10 20:31:22.132061: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" + ] + } + ], + "source": [ + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "train_dataset = train_dataset.batch(800)\n", + "output = model.predict(train_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def visualize_predictions(model, dataset, tile_size=16, max_hits_per_tile=5, images_to_visualize=3):\n", + " \"\"\"\n", + " Visualizes model predictions alongside ground truth hits for a specified number of images from the dataset.\n", + "\n", + " Parameters:\n", + " - model: Trained TensorFlow model.\n", + " - dataset: tf.data.Dataset, the dataset to visualize (e.g., val_dataset).\n", + " - tile_size: int, the size of each tile (default is 16).\n", + " - max_hits_per_tile: int, maximum number of hits per tile (default is 5).\n", + " - images_to_visualize: int, number of images to visualize from the dataset (default is 3).\n", + " \"\"\"\n", + " # Fetch a single batch from the dataset\n", + " for batch_images, batch_true_centers in dataset.take(1):\n", + " # Convert images and labels to NumPy arrays\n", + " images_np = batch_images.numpy()\n", + " true_centers_np = batch_true_centers.numpy()\n", + " \n", + " # Run the model to get predictions\n", + " predictions_np = model.predict(images_np)\n", + " \n", + " # Loop through the specified number of images\n", + " for img_idx in range(min(images_to_visualize, images_np.shape[0])):\n", + " num_tiles = images_np.shape[1]\n", + " grid_size = int(np.ceil(np.sqrt(num_tiles))) # Dynamically determine grid size\n", + " \n", + " fig, axs = plt.subplots(grid_size, grid_size, figsize=(15, 15))\n", + " fig.suptitle(f\"Image {img_idx + 1}: Ground Truth vs Predictions\", fontsize=16)\n", + " \n", + " for tile_idx in range(num_tiles):\n", + " row = tile_idx // grid_size\n", + " col = tile_idx % grid_size\n", + " ax = axs[row, col]\n", + " \n", + " # Display the tile image\n", + " tile_image = images_np[img_idx, tile_idx]\n", + " if tile_image.ndim == 2:\n", + " ax.imshow(tile_image, cmap='gray')\n", + " else:\n", + " ax.imshow(tile_image.squeeze(), cmap='gray') # Handle channels if present\n", + " \n", + " # Plot ground truth hits\n", + " for hit in true_centers_np[img_idx, tile_idx]:\n", + " x_gt, y_gt = hit\n", + " if not (x_gt == 0 and y_gt == 0): # Exclude padding\n", + " ax.scatter(x_gt * tile_size, y_gt * tile_size, \n", + " c='green', marker='o', label='Ground Truth')\n", + " \n", + " # Plot predicted hits\n", + " predicted_hits = predictions_np[img_idx, tile_idx]\n", + " for hit in predicted_hits:\n", + " x_pred, y_pred = hit\n", + " ax.scatter(x_pred * tile_size, y_pred * tile_size, \n", + " c='red', marker='x', label='Prediction')\n", + " \n", + " ax.axis('off') # Hide axis ticks\n", + " \n", + " # Create a single legend for the entire figure\n", + " handles, labels = axs[0,0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout(rect=[0, 0, 1, 0.96]) # Adjust layout to make space for the title and legend\n", + " plt.show()\n", + " \n", + " break # Only process the first batch\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index 1 is out of bounds for axis 1 with size 1", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[44], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Usage Example\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# Ensure that the model and val_dataset are already defined as per your workflow\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m \u001b[43mvisualize_predictions\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mdataset\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mtile_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m16\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_hits_per_tile\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[43mimages_to_visualize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Change this to visualize more or fewer images\u001b[39;49;00m\n\u001b[1;32m 10\u001b[0m \u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[42], line 53\u001b[0m, in \u001b[0;36mvisualize_predictions\u001b[0;34m(model, dataset, tile_size, max_hits_per_tile, images_to_visualize)\u001b[0m\n\u001b[1;32m 49\u001b[0m ax\u001b[38;5;241m.\u001b[39mscatter(x_gt \u001b[38;5;241m*\u001b[39m tile_size, y_gt \u001b[38;5;241m*\u001b[39m tile_size, \n\u001b[1;32m 50\u001b[0m c\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgreen\u001b[39m\u001b[38;5;124m'\u001b[39m, marker\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mo\u001b[39m\u001b[38;5;124m'\u001b[39m, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mGround Truth\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 52\u001b[0m \u001b[38;5;66;03m# Plot predicted hits\u001b[39;00m\n\u001b[0;32m---> 53\u001b[0m predicted_hits \u001b[38;5;241m=\u001b[39m \u001b[43mpredictions_np\u001b[49m\u001b[43m[\u001b[49m\u001b[43mimg_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtile_idx\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m hit \u001b[38;5;129;01min\u001b[39;00m predicted_hits:\n\u001b[1;32m 55\u001b[0m x_pred, y_pred \u001b[38;5;241m=\u001b[39m hit\n", + "\u001b[0;31mIndexError\u001b[0m: index 1 is out of bounds for axis 1 with size 1" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Usage Example\n", + "# Ensure that the model and val_dataset are already defined as per your workflow\n", + "\n", + "visualize_predictions(\n", + " model=model,\n", + " dataset=val_dataset,\n", + " tile_size=16,\n", + " max_hits_per_tile=5,\n", + " images_to_visualize=3 # Change this to visualize more or fewer images\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "# Define the function for visualizing midpoints\n", + "def visualize_midpoints(image, midpoints, title=\"Predicted Midpoint Visualization\"):\n", + " \"\"\"\n", + " Visualizes midpoints on an image without using a probability vector.\n", + "\n", + " Parameters:\n", + " - image: A 3D tensor representing the image.\n", + " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + " - title: The title of the plot.\n", + "\n", + " Returns:\n", + " None (displays the image with midpoints).\n", + " \"\"\"\n", + " # Convert to NumPy arrays for easier handling\n", + " image_np = image\n", + " midpoints_np = midpoints\n", + "\n", + " # Denormalize image if necessary (adjust based on your normalization method)\n", + " denormalized_image = image_np # Modify if normalization was applied during training\n", + "\n", + " # Visualize the image\n", + " plt.figure(figsize=(4, 4))\n", + " plt.imshow(denormalized_image, cmap='gray')\n", + " plt.title(title)\n", + "\n", + " # Plot midpoints directly, only if they are not (0, 0)\n", + " for i, (x, y) in enumerate(midpoints_np):\n", + " if x >= 0 and y >= 0: # Only plot if the point is not (0, 0)\n", + " plt.scatter(x, y, color='red', s=5)\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "Invalid shape (16, 16, 16) for image data", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[41], line 6\u001b[0m\n\u001b[1;32m 2\u001b[0m index_to_visualize \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;28mlen\u001b[39m(all_images))\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# index_to_visualize = 11548\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# Visualize the selected image with predicted and true midpoints\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m \u001b[43mvisualize_midpoints\u001b[49m\u001b[43m(\u001b[49m\u001b[43mall_images\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindex_to_visualize\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mall_pred_midpoints\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindex_to_visualize\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtitle\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mPredicted Midpoints\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m visualize_midpoints(all_images[index_to_visualize], all_true_midpoints[index_to_visualize, \u001b[38;5;241m0\u001b[39m, :, :] , title\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mGround Truth Midpoints\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "Cell \u001b[0;32mIn[35], line 27\u001b[0m, in \u001b[0;36mvisualize_midpoints\u001b[0;34m(image, midpoints, title)\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# Visualize the image\u001b[39;00m\n\u001b[1;32m 26\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m4\u001b[39m))\n\u001b[0;32m---> 27\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimshow\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdenormalized_image\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcmap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mgray\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 28\u001b[0m plt\u001b[38;5;241m.\u001b[39mtitle(title)\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m# Plot midpoints directly, only if they are not (0, 0)\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/pyplot.py:3562\u001b[0m, in \u001b[0;36mimshow\u001b[0;34m(X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, data, **kwargs)\u001b[0m\n\u001b[1;32m 3541\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mimshow)\n\u001b[1;32m 3542\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mimshow\u001b[39m(\n\u001b[1;32m 3543\u001b[0m X: ArrayLike \u001b[38;5;241m|\u001b[39m PIL\u001b[38;5;241m.\u001b[39mImage\u001b[38;5;241m.\u001b[39mImage,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 3560\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 3561\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m AxesImage:\n\u001b[0;32m-> 3562\u001b[0m __ret \u001b[38;5;241m=\u001b[39m \u001b[43mgca\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimshow\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 3563\u001b[0m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3564\u001b[0m \u001b[43m \u001b[49m\u001b[43mcmap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcmap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3565\u001b[0m \u001b[43m \u001b[49m\u001b[43mnorm\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnorm\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3566\u001b[0m \u001b[43m \u001b[49m\u001b[43maspect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maspect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3567\u001b[0m \u001b[43m \u001b[49m\u001b[43minterpolation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterpolation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3568\u001b[0m \u001b[43m \u001b[49m\u001b[43malpha\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43malpha\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3569\u001b[0m \u001b[43m \u001b[49m\u001b[43mvmin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvmin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3570\u001b[0m \u001b[43m \u001b[49m\u001b[43mvmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvmax\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3571\u001b[0m \u001b[43m \u001b[49m\u001b[43morigin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morigin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3572\u001b[0m \u001b[43m \u001b[49m\u001b[43mextent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextent\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3573\u001b[0m \u001b[43m \u001b[49m\u001b[43minterpolation_stage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterpolation_stage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3574\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilternorm\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilternorm\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3575\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilterrad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilterrad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3576\u001b[0m \u001b[43m \u001b[49m\u001b[43mresample\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresample\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3577\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3578\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdata\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m}\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m{\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3579\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 3580\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3581\u001b[0m sci(__ret)\n\u001b[1;32m 3582\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m __ret\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/__init__.py:1473\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1470\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 1471\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner\u001b[39m(ax, \u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 1472\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1473\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1474\u001b[0m \u001b[43m \u001b[49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1475\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1476\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[43mk\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1478\u001b[0m bound \u001b[38;5;241m=\u001b[39m new_sig\u001b[38;5;241m.\u001b[39mbind(ax, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 1479\u001b[0m auto_label \u001b[38;5;241m=\u001b[39m (bound\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget(label_namer)\n\u001b[1;32m 1480\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m bound\u001b[38;5;241m.\u001b[39mkwargs\u001b[38;5;241m.\u001b[39mget(label_namer))\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/axes/_axes.py:5895\u001b[0m, in \u001b[0;36mAxes.imshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m 5892\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m aspect \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 5893\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mset_aspect(aspect)\n\u001b[0;32m-> 5895\u001b[0m \u001b[43mim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5896\u001b[0m im\u001b[38;5;241m.\u001b[39mset_alpha(alpha)\n\u001b[1;32m 5897\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m im\u001b[38;5;241m.\u001b[39mget_clip_path() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 5898\u001b[0m \u001b[38;5;66;03m# image does not already have clipping set, clip to Axes patch\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/image.py:729\u001b[0m, in \u001b[0;36m_ImageBase.set_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m 727\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(A, PIL\u001b[38;5;241m.\u001b[39mImage\u001b[38;5;241m.\u001b[39mImage):\n\u001b[1;32m 728\u001b[0m A \u001b[38;5;241m=\u001b[39m pil_to_array(A) \u001b[38;5;66;03m# Needed e.g. to apply png palette.\u001b[39;00m\n\u001b[0;32m--> 729\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_normalize_image_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43mA\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 730\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_imcache \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 731\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstale \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/objectdetection/lib/python3.11/site-packages/matplotlib/image.py:697\u001b[0m, in \u001b[0;36m_ImageBase._normalize_image_array\u001b[0;34m(A)\u001b[0m\n\u001b[1;32m 695\u001b[0m A \u001b[38;5;241m=\u001b[39m A\u001b[38;5;241m.\u001b[39msqueeze(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m) \u001b[38;5;66;03m# If just (M, N, 1), assume scalar and apply colormap.\u001b[39;00m\n\u001b[1;32m 696\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m A\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m] \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m]):\n\u001b[0;32m--> 697\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid shape \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mA\u001b[38;5;241m.\u001b[39mshape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m for image data\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 698\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m:\n\u001b[1;32m 699\u001b[0m \u001b[38;5;66;03m# If the input data has values outside the valid range (after\u001b[39;00m\n\u001b[1;32m 700\u001b[0m \u001b[38;5;66;03m# normalisation), we issue a warning and then clip X to the bounds\u001b[39;00m\n\u001b[1;32m 701\u001b[0m \u001b[38;5;66;03m# - otherwise casting wraps extreme values, hiding outliers and\u001b[39;00m\n\u001b[1;32m 702\u001b[0m \u001b[38;5;66;03m# making reliable interpretation impossible.\u001b[39;00m\n\u001b[1;32m 703\u001b[0m high \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m255\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39missubdtype(A\u001b[38;5;241m.\u001b[39mdtype, np\u001b[38;5;241m.\u001b[39minteger) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m1\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: Invalid shape (16, 16, 16) for image data" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Select an index to visualize from the entire dataset\n", + "index_to_visualize = np.random.randint(0, len(all_images))\n", + "\n", + "# index_to_visualize = 11548\n", + "# Visualize the selected image with predicted and true midpoints\n", + "visualize_midpoints(all_images[index_to_visualize], all_pred_midpoints[index_to_visualize, 0, :, :] , title=\"Predicted Midpoints\")\n", + "visualize_midpoints(all_images[index_to_visualize], all_true_midpoints[index_to_visualize, 0, :, :] , title=\"Ground Truth Midpoints\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import numpy as np\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + " return reconstructed_image\n", + "\n", + "def filter_predictions(predictions, threshold=0.5):\n", + " # Remove predictions close to (0,0) by applying a threshold\n", + " return [(x, y) for (x, y) in predictions if (x**2 + y**2) > threshold**2]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "def reconstruct_image_from_tiles(tiles, tile_size, num_tiles_per_row):\n", + " \"\"\"\n", + " Reconstructs the original image from tiles.\n", + "\n", + " Parameters:\n", + " - tiles: np.array, tiles of the image with shape (num_tiles, tile_size, tile_size).\n", + " - tile_size: int, the size of each tile.\n", + " - num_tiles_per_row: int, number of tiles per row/column in the original image.\n", + "\n", + " Returns:\n", + " - image: np.array, the reconstructed original image.\n", + " \"\"\"\n", + " # Initialize an empty array for the reconstructed image\n", + " reconstructed_image = np.zeros((tile_size * num_tiles_per_row, tile_size * num_tiles_per_row))\n", + " \n", + " # Fill the reconstructed image with the tiles in the correct position\n", + " for idx, tile in enumerate(tiles):\n", + " row = (idx // num_tiles_per_row) * tile_size\n", + " col = (idx % num_tiles_per_row) * tile_size\n", + " reconstructed_image[row:row + tile_size, col:col + tile_size] = tile\n", + "\n", + " return reconstructed_image\n", + "\n", + "def filter_predictions(predictions, threshold):\n", + " \"\"\"\n", + " Filters predictions by removing those close to (0, 0) using a threshold.\n", + " \n", + " Parameters:\n", + " - predictions: list of tuples representing predicted (x, y) coordinates.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \n", + " Returns:\n", + " - list of valid (x, y) predictions.\n", + " \"\"\"\n", + " return [(x, y) for (x, y) in predictions if (x**2 + y**2) > threshold**2]\n", + "\n", + "def visualize_predictions_without_confidence(model, dataset, tile_size=16, max_hits_per_tile=5, num_images=1, threshold = 0.6):\n", + " \"\"\"\n", + " Visualizes the model's predictions on a random sample of images from the dataset,\n", + " showing both the original image and tiled predictions without confidence filtering.\n", + "\n", + " Parameters:\n", + " - model: tf.keras.Model, the trained model to make predictions.\n", + " - dataset: tf.data.Dataset, the dataset to predict and visualize.\n", + " - tile_size: int, the size of each tile.\n", + " - max_hits_per_tile: int, maximum number of hits per tile.\n", + " - num_images: int, number of random images to visualize.\n", + " - threshold: float, minimum distance from (0, 0) for a hit to be considered valid.\n", + " \"\"\"\n", + " # Take one batch from the dataset for prediction\n", + " images, true_centers = next(iter(dataset.shuffle(buffer_size=1000))) # Shuffle and take one batch\n", + "\n", + " # Randomly select indices of images to visualize\n", + " num_tiles_per_image = 16 # 4x4 grid, 16 tiles per image\n", + " num_tiles_per_row = int(np.sqrt(num_tiles_per_image)) # Assuming a square grid\n", + " indices = random.sample(range(images.shape[0] // num_tiles_per_image), num_images) # Select random images\n", + "\n", + " # Make predictions on the entire batch\n", + " predictions = model.predict(images)\n", + "\n", + " # Visualize the selected images\n", + " for img_idx in indices:\n", + " # Select the tiles corresponding to the current image\n", + " image_tiles = images[img_idx * num_tiles_per_image : (img_idx + 1) * num_tiles_per_image]\n", + " reconstructed_image = reconstruct_image_from_tiles(\n", + " image_tiles.numpy().reshape(-1, tile_size, tile_size), \n", + " tile_size, \n", + " num_tiles_per_row\n", + " )\n", + "\n", + " # Plot the original image with overlayed predictions\n", + " fig, ax_orig = plt.subplots(1, 1, figsize=(6, 6))\n", + " ax_orig.imshow(reconstructed_image, cmap='gray')\n", + " ax_orig.set_title(f\"Original Image with Predicted Hits (Image {img_idx})\")\n", + "\n", + " # Overlay true and predicted centers on the original image\n", + " for tile_idx in range(num_tiles_per_image):\n", + " row_offset = (tile_idx // num_tiles_per_row) * tile_size\n", + " col_offset = (tile_idx % num_tiles_per_row) * tile_size\n", + "\n", + " # Get true and predicted centers for each tile\n", + " true_tile_centers = true_centers[img_idx * num_tiles_per_image + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * num_tiles_per_image + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Plot true hits in green\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted hits in red, with threshold filtering\n", + " for (x, y) in filter_predictions(predicted_tile_centers, threshold=threshold):\n", + " ax_orig.scatter(col_offset + x * tile_size, row_offset + y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Add legend\n", + " handles, labels = ax_orig.get_legend_handles_labels()\n", + " ax_orig.legend(handles, labels, loc='upper right')\n", + "\n", + " # Now plot the 4x4 tiled images with predictions and true hits\n", + " fig, axs = plt.subplots(num_tiles_per_row, num_tiles_per_row, figsize=(10, 10))\n", + " fig.suptitle(f\"Tiled Predictions and True Hits (Image {img_idx})\")\n", + "\n", + " for tile_idx, ax in enumerate(axs.flat):\n", + " true_tile_centers = true_centers[img_idx * num_tiles_per_image + tile_idx].numpy().reshape(-1, 2)\n", + " predicted_tile_centers = predictions[img_idx * num_tiles_per_image + tile_idx].reshape(max_hits_per_tile, 2)\n", + "\n", + " # Display the tile\n", + " ax.imshow(images[img_idx * num_tiles_per_image + tile_idx].numpy().reshape(tile_size, tile_size), cmap='gray')\n", + "\n", + " # Plot true centers\n", + " for (x, y) in true_tile_centers:\n", + " if (x, y) != (0, 0): # Ignore padding\n", + " ax.scatter(x * tile_size, y * tile_size, c='green', marker='x', s=40, label='True Hit' if tile_idx == 0 else \"\")\n", + "\n", + " # Plot predicted centers with threshold filtering\n", + " for (x, y) in filter_predictions(predicted_tile_centers, threshold=threshold):\n", + " ax.scatter(x * tile_size, y * tile_size, c='red', marker='o', s=30, label='Predicted Hit' if tile_idx == 0 else \"\")\n", + "\n", + " ax.axis('on')\n", + "\n", + " handles, labels = axs[0, 0].get_legend_handles_labels()\n", + " fig.legend(handles, labels, loc='upper right')\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m32/32\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example usage with tile_size=16\n", + "visualize_predictions_without_confidence(model, val_dataset_flat, tile_size=16, max_hits_per_tile=5, num_images=2)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "objectdetection", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ElectronCountingProject/Back To Original Project/model.ipynb b/ElectronCountingProject/Back To Original Project/model.ipynb index 07e733e..d73c327 100644 --- a/ElectronCountingProject/Back To Original Project/model.ipynb +++ b/ElectronCountingProject/Back To Original Project/model.ipynb @@ -1769,7 +1769,7 @@ ], "metadata": { "kernelspec": { - "display_name": "electrondetection", + "display_name": "objectdetection", "language": "python", "name": "python3" }, diff --git a/ElectronCountingProject/Old Project/Jingrui's data.ipynb b/ElectronCountingProject/Old Project/Jingrui's data.ipynb index 9dcfe6b..3e45aac 100644 --- a/ElectronCountingProject/Old Project/Jingrui's data.ipynb +++ b/ElectronCountingProject/Old Project/Jingrui's data.ipynb @@ -9,20 +9,20 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-08-27 17:38:06.434900: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2024-08-27 17:38:06.450346: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2024-08-27 17:38:06.464060: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2024-08-27 17:38:06.468202: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "2024-08-27 17:38:06.481407: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "2025-01-20 16:12:19.961693: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-01-20 16:12:19.973357: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-01-20 16:12:19.985750: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-01-20 16:12:19.989452: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-01-20 16:12:19.999568: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2024-08-27 17:38:07.100253: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + "2025-01-20 16:12:20.627394: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "device /gpu:7\n" + "device /gpu:0\n" ] } ], @@ -41,8 +41,8 @@ " # Restrict TensorFlow to only use the second GPU\n", " gpus = tf.config.experimental.list_physical_devices('GPU')\n", " if gpus:\n", - " tf.config.experimental.set_visible_devices(gpus[7], 'GPU')\n", - " device = '/gpu:7'\n", + " tf.config.experimental.set_visible_devices(gpus[0], 'GPU')\n", + " device = '/gpu:0'\n", " except RuntimeError as e:\n", " print(e)\n", "\n", @@ -66,14 +66,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "2024-08-27 17:39:16.829813: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79078 MB memory: -> device: 7, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:c9:00.0, compute capability: 8.0\n" + "2025-01-20 16:12:25.015984: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n" ] } ], @@ -103,22 +103,22 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -128,12 +128,312 @@ } ], "source": [ - "plt.imshow(images[2])" + "l = np.random.randint(0, len(images_np))\n", + "plt.imshow(images[7])" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1. , 0.7578125, 0.1953125],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ],\n", + " [0. , 0. , 0. ]])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "center_coordinates[7]" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -152,6 +452,26 @@ "# test_dataset = test_dataset.batch(batch_size) " ] }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<_BatchDataset element_spec=(TensorSpec(shape=(None, 64, 64), dtype=tf.float64, name=None), {'x_prob_reshape': TensorSpec(shape=(None, 1, 280, 1), dtype=tf.float64, name=None), 'x_midpoints_reshape': TensorSpec(shape=(None, 1, 280, 2), dtype=tf.float64, name=None)})>" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset" + ] + }, { "cell_type": "code", "execution_count": 65, @@ -280,7 +600,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -357,7 +677,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -371,191 +691,57 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-07-16 20:38:08.061252: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[2000,512,8,8]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,8,8]{3,2,1,0}, f32[512,512,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:08.387292: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.326109801s\n", - "Trying algorithm eng0{} for conv (f32[2000,512,8,8]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,8,8]{3,2,1,0}, f32[512,512,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:14.479468: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[2000,512,16,16]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,16,16]{3,2,1,0}, f32[512,512,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:18.773448: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 5.294102465s\n", - "Trying algorithm eng0{} for conv (f32[2000,512,16,16]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,16,16]{3,2,1,0}, f32[512,512,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:30.437974: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[2000,256,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,32,32]{3,2,1,0}, f32[512,256,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:40.031925: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 10.594039549s\n", - "Trying algorithm eng0{} for conv (f32[2000,256,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,32,32]{3,2,1,0}, f32[512,256,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:45.782319: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng2{k2=1,k3=0} for conv (f32[2000,256,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,32,32]{3,2,1,0}, f32[512,256,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:45.805357: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.02315259s\n", - "Trying algorithm eng2{k2=1,k3=0} for conv (f32[2000,256,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,32,32]{3,2,1,0}, f32[512,256,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:51.006026: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[2000,256,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[256,256,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:38:55.341234: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 5.335337682s\n", - "Trying algorithm eng0{} for conv (f32[2000,256,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[256,256,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:01.938780: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[2000,128,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[256,128,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:03.616528: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 2.67782885s\n", - "Trying algorithm eng0{} for conv (f32[2000,128,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[256,128,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:07.262113: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[2000,128,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,128,32,32]{3,2,1,0}, f32[128,128,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:07.604614: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.34264981s\n", - "Trying algorithm eng0{} for conv (f32[2000,128,32,32]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,128,32,32]{3,2,1,0}, f32[128,128,3,3]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardInput\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "E0000 00:00:1721162352.237094 280492 gpu_timer.cc:183] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\n", - "E0000 00:00:1721162352.427083 280492 gpu_timer.cc:183] Delay kernel timed out: measured time has sub-optimal accuracy. There may be a missing warmup execution, please investigate in Nsight Systems.\n", - "2024-07-16 20:39:16.885078: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[128,64,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,64,32,32]{3,2,1,0}, f32[2000,128,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:17.105415: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.220455137s\n", - "Trying algorithm eng0{} for conv (f32[128,64,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,64,32,32]{3,2,1,0}, f32[2000,128,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:21.022490: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[128,128,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,128,32,32]{3,2,1,0}, f32[2000,128,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:22.472246: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 2.449847324s\n", - "Trying algorithm eng0{} for conv (f32[128,128,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,128,32,32]{3,2,1,0}, f32[2000,128,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:28.950288: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[256,128,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,128,32,32]{3,2,1,0}, f32[2000,256,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:32.911177: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 4.961019044s\n", - "Trying algorithm eng0{} for conv (f32[256,128,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,128,32,32]{3,2,1,0}, f32[2000,256,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:43.612762: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[256,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,256,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:52.592312: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 9.979735495s\n", - "Trying algorithm eng0{} for conv (f32[256,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,256,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:55.649882: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng18{k11=2} for conv (f32[256,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,256,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:39:55.764062: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.114300384s\n", - "Trying algorithm eng18{k11=2} for conv (f32[256,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,256,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:05.543964: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng20{k2=0,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:05.561910: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.01805049s\n", - "Trying algorithm eng20{k2=0,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:06.562126: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng20{k2=5,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:06.580719: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.018717999s\n", - "Trying algorithm eng20{k2=5,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:07.580920: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng20{k2=3,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:07.600741: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.019941089s\n", - "Trying algorithm eng20{k2=3,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:08.600931: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng20{k2=4,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:08.621001: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.020178189s\n", - "Trying algorithm eng20{k2=4,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:09.621198: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng1{k2=0,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:09.711255: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.090171335s\n", - "Trying algorithm eng1{k2=0,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:10.711460: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng1{k2=5,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:10.800214: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.088874645s\n", - "Trying algorithm eng1{k2=5,k3=0} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:11.800436: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:30.973556: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 20.173257158s\n", - "Trying algorithm eng0{} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:35.528691: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng40{k2=14,k6=0,k12=-1,k13=1,k14=0,k15=0,k17=2,k22=3} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:35.789647: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.261094885s\n", - "Trying algorithm eng40{k2=14,k6=0,k12=-1,k13=1,k14=0,k15=0,k17=2,k22=3} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:36.789860: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng18{k11=2} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:37.979882: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 2.190141459s\n", - "Trying algorithm eng18{k11=2} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,256,32,32]{3,2,1,0}, f32[2000,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:44.653570: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[512,512,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,16,16]{3,2,1,0}, f32[2000,512,16,16]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:52.991059: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 9.337621864s\n", - "Trying algorithm eng0{} for conv (f32[512,512,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,16,16]{3,2,1,0}, f32[2000,512,16,16]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:57.934431: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[512,512,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,8,8]{3,2,1,0}, f32[2000,512,8,8]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", - "2024-07-16 20:40:59.150481: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 2.216167728s\n", - "Trying algorithm eng0{} for conv (f32[512,512,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[2000,512,8,8]{3,2,1,0}, f32[2000,512,8,8]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n" + "I0000 00:00:1737406386.184386 333873 service.cc:146] XLA service 0x7fda480044c0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", + "I0000 00:00:1737406386.184452 333873 service.cc:154] StreamExecutor device (0): NVIDIA A100 80GB PCIe, Compute Capability 8.0\n", + "2025-01-20 15:53:06.265799: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", + "2025-01-20 15:53:06.604158: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2025-01-20 15:53:15.135494: E external/local_xla/xla/service/slow_operation_alarm.cc:65] Trying algorithm eng0{} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[128,256,32,32]{3,2,1,0}, f32[128,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n", + "2025-01-20 15:53:15.219549: E external/local_xla/xla/service/slow_operation_alarm.cc:133] The operation took 1.084238956s\n", + "Trying algorithm eng0{} for conv (f32[512,256,3,3]{3,2,1,0}, u8[0]{0}) custom-call(f32[128,256,32,32]{3,2,1,0}, f32[128,512,32,32]{3,2,1,0}), window={size=3x3 pad=1_1x1_1}, dim_labels=bf01_oi01->bf01, custom_call_target=\"__cudnn$convBackwardFilter\", backend_config={\"operation_queue_id\":\"0\",\"wait_on_operation_queues\":[],\"cudnn_conv_backend_config\":{\"conv_result_scale\":1,\"activation_mode\":\"kNone\",\"side_input_scale\":0,\"leakyrelu_alpha\":0},\"force_earliest_schedule\":false} is taking a while...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 5/79\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2s\u001b[0m 35ms/step - loss: 0.9982" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I0000 00:00:1737406398.511014 333873 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m198s\u001b[0m 497ms/step - loss: 0.0600\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 82ms/step - loss: 0.6951\n", "Epoch 2/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 480ms/step - loss: 0.0629\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.7758\n", "Epoch 3/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 481ms/step - loss: 0.0561\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.8186\n", "Epoch 4/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 481ms/step - loss: 0.0578\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.7694\n", "Epoch 5/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 480ms/step - loss: 0.0535\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.7883\n", "Epoch 6/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 480ms/step - loss: 0.0533\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.7435\n", "Epoch 7/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 481ms/step - loss: 0.0525\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.7334\n", "Epoch 8/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 481ms/step - loss: 0.0519\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.6615\n", "Epoch 9/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 481ms/step - loss: 0.0516\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 32ms/step - loss: 0.6666\n", "Epoch 10/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 481ms/step - loss: 0.0513\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.6535\n", "Epoch 11/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0512\n", + "\u001b[1m79/79\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 33ms/step - loss: 0.6345\n", "Epoch 12/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0510\n", - "Epoch 13/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0509\n", - "Epoch 14/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0507\n", - "Epoch 15/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0506\n", - "Epoch 16/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0505\n", - "Epoch 17/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0504\n", - "Epoch 18/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0503\n", - "Epoch 19/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 483ms/step - loss: 0.0503\n", - "Epoch 20/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0502\n", - "Epoch 21/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0501\n", - "Epoch 22/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 483ms/step - loss: 0.0501\n", - "Epoch 23/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 482ms/step - loss: 0.0500\n", - "Epoch 24/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0499\n", - "Epoch 25/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 483ms/step - loss: 0.0499\n", - "Epoch 26/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0498\n", - "Epoch 27/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0498\n", - "Epoch 28/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0497\n", - "Epoch 29/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0497\n", - "Epoch 30/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0496\n", - "Epoch 31/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0496\n", - "Epoch 32/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0495\n", - "Epoch 33/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 483ms/step - loss: 0.0495\n", - "Epoch 34/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 485ms/step - loss: 0.0494\n", - "Epoch 35/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0494\n", - "Epoch 36/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 485ms/step - loss: 0.0494\n", - "Epoch 37/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0493\n", - "Epoch 38/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0493\n", - "Epoch 39/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0492\n", - "Epoch 40/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0492\n", - "Epoch 41/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 484ms/step - loss: 0.0492\n", - "Epoch 42/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 487ms/step - loss: 0.0491\n", - "Epoch 43/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 490ms/step - loss: 0.0491\n", - "Epoch 44/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 488ms/step - loss: 0.0491\n", - "Epoch 45/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 485ms/step - loss: 0.0490\n", - "Epoch 46/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 489ms/step - loss: 0.0490\n", - "Epoch 47/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 493ms/step - loss: 0.0490\n", - "Epoch 48/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 485ms/step - loss: 0.0489\n", - "Epoch 49/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 488ms/step - loss: 0.0489\n", - "Epoch 50/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 485ms/step - loss: 0.0489\n", - "Epoch 51/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 491ms/step - loss: 0.0488\n", - "Epoch 52/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 501ms/step - loss: 0.0488\n", - "Epoch 53/500\n", - "\u001b[1m5/5\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 494ms/step - loss: 0.0488\n", - "Epoch 54/500\n", - "\u001b[1m3/5\u001b[0m \u001b[32m━━━━━━━━━━━━\u001b[0m\u001b[37m━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 488ms/step - loss: 0.0330" + "\u001b[1m 7/79\u001b[0m \u001b[32m━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2s\u001b[0m 33ms/step - loss: 1.0590" ] } ], @@ -935,7 +1121,7 @@ ], "metadata": { "kernelspec": { - "display_name": "sod", + "display_name": "objectdetection", "language": "python", "name": "python3" }, diff --git a/ElectronCountingProject/weekend steps custom loss.ipynb b/ElectronCountingProject/weekend steps custom loss.ipynb index 2a3ba66..5e626e1 100644 --- a/ElectronCountingProject/weekend steps custom loss.ipynb +++ b/ElectronCountingProject/weekend steps custom loss.ipynb @@ -1522,7 +1522,7 @@ ], "metadata": { "kernelspec": { - "display_name": "electrondetection", + "display_name": "objectdetection", "language": "python", "name": "python3" }, diff --git a/Final Electron counting project/Data Generation for exact center with bounding boxes and labels.ipynb b/Final Electron counting project/Data Generation for exact center with bounding boxes and labels.ipynb new file mode 100644 index 0000000..e0aac7d --- /dev/null +++ b/Final Electron counting project/Data Generation for exact center with bounding boxes and labels.ipynb @@ -0,0 +1,672 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-16 20:08:28.653073: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-09-16 20:08:28.667289: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-09-16 20:08:28.680409: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-09-16 20:08:28.684400: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-09-16 20:08:28.696360: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-09-16 20:08:29.322799: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device /gpu:9\n" + ] + } + ], + "source": [ + "import os\n", + "import tensorflow as tf\n", + "\n", + "# Set CUDA device order and visible devices\n", + "os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2,3,4,5,6,7,8,9\"\n", + "\n", + "# Set the device\n", + "device = '/cpu:0'\n", + "if tf.config.experimental.list_physical_devices('GPU'):\n", + " try:\n", + " # Restrict TensorFlow to only use the second GPU\n", + " gpus = tf.config.experimental.list_physical_devices('GPU')\n", + " if gpus:\n", + " tf.config.experimental.set_visible_devices(gpus[9], 'GPU')\n", + " device = '/gpu:9'\n", + " except RuntimeError as e:\n", + " print(e)\n", + "\n", + "print(\"device\", device)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(98000, 19, 19)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tifffile as tiff\n", + "import os\n", + "\n", + "# Load the TIFF stack\n", + "file_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "tiff_stack = tiff.imread(file_path)\n", + "\n", + "# Check the shape of the stack to ensure it is a 3D array\n", + "print(tiff_stack.shape) # (num_slices, height, width)\n", + "\n", + "# Verify the shape\n", + "if len(tiff_stack.shape) != 3:\n", + " raise ValueError(\"The loaded TIFF stack is not a 3D array.\")\n", + "\n", + "# Function to plot multiple slices in a grid\n", + "def plot_slices(start, end):\n", + " fig, axes = plt.subplots(nrows=10, ncols=10, figsize=(15, 15))\n", + " fig.suptitle(f'Slices {start} to {end-1}')\n", + " \n", + " for i, ax in enumerate(axes.flat):\n", + " slice_index = start + i\n", + " if slice_index < end:\n", + " ax.imshow(tiff_stack[slice_index], cmap='gray')\n", + " ax.set_title(f'Slice {slice_index}')\n", + " ax.axis('off')\n", + " else:\n", + " ax.axis('off')\n", + " \n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.95)\n", + " plt.show()\n", + "\n", + "# Plot the first 100 slices\n", + "plot_slices(7899, 7999)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### THIS IS MY MAIN CODE" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating images: 100%|██████████| 1000/1000 [00:00<00:00, 7573.49it/s]\n", + "Generating noise-only images: 0it [00:00, ?it/s]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import random\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "import h5py\n", + "\n", + "class ImageProcessor:\n", + " \"\"\"Image generation class\"\"\" \n", + " \n", + " def __init__(self, \n", + " num_to_generate,\n", + " tiff_path, \n", + " dark_noise_path, \n", + " canvas_size=(256, 256), \n", + " max_electron_hits=20):\n", + " self.tiff_path = tiff_path\n", + " self.dark_noise_path = dark_noise_path\n", + " self.canvas_size = canvas_size\n", + " self.num_to_generate = num_to_generate\n", + " self.max_electron_hits = max_electron_hits\n", + " \n", + " # Loads the images from the tiff file\n", + " self.images = self.load_images_from_tiff(tiff_path)\n", + " self.dark_noise_images = self.load_images_from_tiff(dark_noise_path)\n", + " \n", + " # Creates a dark stack of the same size as the canvas\n", + " self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + " \n", + " def load_images_from_tiff(self, tiff_path):\n", + " with Image.open(tiff_path) as img:\n", + " images = []\n", + " for i in range(img.n_frames):\n", + " img.seek(i)\n", + " images.append(np.array(img))\n", + " return images\n", + " \n", + " def noisy(self, noise_typ, image): \n", + " if noise_typ == \"gauss\":\n", + " row, col = image.shape\n", + " mean = 0\n", + " var = 0.0001\n", + " sigma = var ** 0.5\n", + " threshold = 8\n", + " gauss = np.random.normal(mean, sigma, (row, col))\n", + " tnoisy = image + gauss\n", + "\n", + " tnoisy[tnoisy < threshold] = 0\n", + " noisy = np.round(tnoisy)\n", + " return noisy\n", + "\n", + " def deadcorr(self, image):\n", + " temp = image.copy()\n", + " temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + " return temp\n", + "\n", + " def dark_stack(self, imgsize):\n", + " dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + " dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + " return dark_noise_stack_cropped\n", + "\n", + " def place_image_on_canvas(self):\n", + " \"\"\"Places electron hits on the canvas, returns the canvas, centers, \n", + " centers_training, bounding_boxes, and spot labels.\"\"\"\n", + " canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + " height, width = self.images[0].shape\n", + " max_x = self.canvas_size[1]\n", + " max_y = self.canvas_size[0]\n", + "\n", + " centers = []\n", + " centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + " bounding_boxes = np.zeros((self.max_electron_hits, 4), dtype=np.float32)\n", + " spot_labels = []\n", + "\n", + " for i in range(self.max_electron_hits):\n", + " x = random.randint(1 - width//2, max_x - width//2 - 1)\n", + " y = random.randint(1 - height//2, max_y - height//2 - 1)\n", + " \n", + " index = 95 # or random.randint(0, 97999)\n", + " hit = self.images[index]\n", + " \n", + " y_min, y_max = y, y + height\n", + " x_min, x_max = x, x + width\n", + " x_center = x + width // 2\n", + " y_center = y + height // 2\n", + " \n", + " if y_min < 0:\n", + " hit = hit[-y_min:, :]\n", + " y_min = 0\n", + " if y_max > max_y:\n", + " hit = hit[:-(y_max - max_y), :]\n", + " y_max = max_y\n", + " if x_min < 0:\n", + " hit = hit[:, -x_min:]\n", + " x_min = 0\n", + " if x_max > max_x:\n", + " hit = hit[:, :-(x_max - max_x)]\n", + " x_max = max_x\n", + " \n", + " canvas[y_min:y_max, x_min:x_max] = np.clip(\n", + " canvas[y_min:y_max, x_min:x_max] + hit, 0, 255\n", + " )\n", + "\n", + " centers.append((x_center, y_center))\n", + " centers_training[i, 0] = 1 # indicates there's an electron\n", + " centers_training[i, 1] = x_center\n", + " centers_training[i, 2] = y_center\n", + " \n", + " # 3x3 bounding box around the center\n", + " xmin = x_center - 1\n", + " ymin = y_center - 1\n", + " xmax = x_center + 1\n", + " ymax = y_center + 1\n", + " bounding_boxes[i] = [xmin, ymin, xmax, ymax]\n", + "\n", + " # Label for each electron\n", + " spot_labels.append(\"electron\")\n", + "\n", + " return canvas, centers_training, bounding_boxes, spot_labels\n", + "\n", + " def generate_multiple_images(self):\n", + " results = []\n", + " for _ in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + " canvas, centers_training, bounding_boxes, spot_labels = self.place_image_on_canvas()\n", + " results.append((canvas, centers_training, bounding_boxes, spot_labels))\n", + " return results\n", + "\n", + " def generate_noise_only_images(self, num_images):\n", + " noise_images = []\n", + " for _ in tqdm(range(num_images), desc=\"Generating noise-only images\"):\n", + " canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + " canvas = self.noisy('gauss', canvas)\n", + " noise_int = np.random.randint(len(self.dark_noise))\n", + " canvas = canvas + self.dark_noise[noise_int]\n", + " noise_images.append(canvas)\n", + " return noise_images\n", + " \n", + " def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + " total_images = len(data_with_objects) + len(noise_images)\n", + " combined_data = []\n", + "\n", + " # Add labels: 1 for images with electrons, 0 for noise-only\n", + " for item in data_with_objects:\n", + " canvas, centers_training, bboxes, spot_labels = item\n", + " combined_data.append((canvas, centers_training, bboxes, spot_labels, 1))\n", + "\n", + " for noise_image in noise_images:\n", + " dummy_centers = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + " dummy_bboxes = np.zeros((self.max_electron_hits, 4), dtype=np.float32)\n", + " spot_labels = [\"none\"] * self.max_electron_hits\n", + " combined_data.append((noise_image, dummy_centers, dummy_bboxes, spot_labels, 0))\n", + "\n", + " random.shuffle(combined_data)\n", + "\n", + " with h5py.File(filename, 'w') as h5_file:\n", + " theimages = h5_file.create_dataset(\n", + " 'images',\n", + " shape=(total_images, self.canvas_size[0], self.canvas_size[1]),\n", + " dtype='uint8'\n", + " )\n", + " thecenters = h5_file.create_dataset(\n", + " 'centers_training',\n", + " shape=(total_images, self.max_electron_hits, 3),\n", + " dtype='float32'\n", + " )\n", + " thebboxes = h5_file.create_dataset(\n", + " 'bounding_boxes',\n", + " shape=(total_images, self.max_electron_hits, 4),\n", + " dtype='float32'\n", + " )\n", + " labels = h5_file.create_dataset(\n", + " 'labels',\n", + " shape=(total_images,),\n", + " dtype='uint8'\n", + " )\n", + "\n", + " # Create a variable-length string dataset for spot-level labels\n", + " dt_vlen_str = h5py.special_dtype(vlen=str)\n", + " spot_labels_ds = h5_file.create_dataset(\n", + " 'spot_labels',\n", + " shape=(total_images, self.max_electron_hits),\n", + " dtype=dt_vlen_str\n", + " )\n", + "\n", + " for i, (canvas, centers, bboxes, spot_lbls, img_label) in enumerate(combined_data):\n", + " theimages[i] = canvas\n", + " thecenters[i] = centers\n", + " thebboxes[i] = bboxes\n", + " labels[i] = img_label\n", + "\n", + " # Write string labels for each spot\n", + " for j in range(self.max_electron_hits):\n", + " spot_labels_ds[i, j] = spot_lbls[j]\n", + "\n", + "\n", + "# Example usage:\n", + "tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "processor = ImageProcessor(\n", + " num_to_generate=1000, \n", + " tiff_path=tiff_path, \n", + " dark_noise_path=dark_noise_path, \n", + " max_electron_hits=20\n", + ")\n", + "\n", + "data_with_intensity_range = processor.generate_multiple_images()\n", + "noise_only_images = processor.generate_noise_only_images(0)\n", + "\n", + "processor.save_mixed_images_to_h5(\n", + " data_with_intensity_range, \n", + " noise_only_images, \n", + " '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/100Fixed_20_256by256_95indexNoNoise_withBB.h5'\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "this is to test 1 spot" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating images: 100%|██████████| 15000/15000 [00:01<00:00, 14058.79it/s]\n", + "Generating noise-only images: 0it [00:00, ?it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# from PIL import Image\n", + "# from tqdm import tqdm\n", + "# import h5py\n", + "\n", + "# class ImageProcessor:\n", + "# \"\"\"Image generation class\"\"\" \n", + "\n", + "# def __init__(self, \n", + "# num_to_generate,\n", + "# tiff_path, \n", + "# dark_noise_path, \n", + "# canvas_size=(32, 32), \n", + "# max_electron_hits=5): # Set max_electron_hits to 5\n", + "# \"\"\"Initializes the ImageProcessor class\n", + "\n", + "# Args:\n", + "# num_to_generate (int): Number of images to generate\n", + "# tiff_path (str): Location of the tiff file that contains the electron hits\n", + "# dark_noise_path (str): Path to the noisy data\n", + "# canvas_size (tuple, optional): Size of the canvas to place the images on. Defaults to (32, 32).\n", + "# max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 5.\n", + "# \"\"\" \n", + "\n", + "# self.tiff_path = tiff_path\n", + "# self.dark_noise_path = dark_noise_path\n", + "# self.canvas_size = canvas_size\n", + "# self.num_to_generate = num_to_generate\n", + "# self.max_electron_hits = max_electron_hits\n", + "\n", + "# # Loads the images from the tiff file\n", + "# self.images = self.load_images_from_tiff(tiff_path)\n", + "# self.dark_noise_images = self.load_images_from_tiff(dark_noise_path)\n", + "\n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + "\n", + "# def load_images_from_tiff(self, tiff_path):\n", + "# \"\"\"Loads the images from a tiff file\n", + "\n", + "# Args:\n", + "# tiff_path (str): Path to the tiff file\n", + "\n", + "# Returns:\n", + "# list: List of images\n", + "# \"\"\" \n", + "# with Image.open(tiff_path) as img:\n", + "# images = []\n", + "# for i in range(img.n_frames):\n", + "# img.seek(i)\n", + "# images.append(np.array(img))\n", + "# return images\n", + "\n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\n", + "\n", + "# Args:\n", + "# noise_typ (str): Type of noise to add\n", + "# image (numpy array): Image to add noise to\n", + "\n", + "# Returns:\n", + "# numpy array: Noisy image\n", + "# \"\"\"\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.0001\n", + "# sigma = var ** 0.5\n", + "# threshold = 8\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", + "\n", + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\n", + "\n", + "# Args:\n", + "# image (numpy array): Image to correct\n", + "# \"\"\" \n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\n", + "\n", + "# Args:\n", + "# imgsize (int): Size of the images in the stack\n", + "# \"\"\" \n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self):\n", + "# \"\"\"Places 5 electron hits: one at the center and one at each corner of the canvas.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "# height, width = self.images[0].shape\n", + "# max_x, max_y = self.canvas_size[1], self.canvas_size[0]\n", + "# centers = []\n", + "# centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + "\n", + "# # Define positions: corners and center\n", + "# positions = {\n", + "# 0: (0, 0), # Top-left corner\n", + "# 1: (max_x - width, 0), # Top-right corner\n", + "# 2: (0, max_y - height), # Bottom-left corner\n", + "# 3: (max_x - width, max_y - height), # Bottom-right corner\n", + "# 4: ((max_x - width) // 2, (max_y - height) // 2) # Center\n", + "# }\n", + "\n", + "# for i in range(self.max_electron_hits):\n", + "# x, y = positions[i]\n", + "\n", + "# # Select an electron hit\n", + "# index = random.randint(0, len(self.images) - 1)\n", + "# hit = self.images[index]\n", + "\n", + "# # Define the placement boundaries\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + "\n", + "# # Handle cases where the electron hit image goes beyond the canvas boundaries\n", + "# if y_min < 0:\n", + "# hit = hit[-y_min:, :]\n", + "# y_min = 0\n", + "\n", + "# if y_max > max_y:\n", + "# hit = hit[:-(y_max - max_y), :]\n", + "# y_max = max_y\n", + "\n", + "# if x_min < 0:\n", + "# hit = hit[:, -x_min:]\n", + "# x_min = 0\n", + "\n", + "# if x_max > max_x:\n", + "# hit = hit[:, :-(x_max - max_x)]\n", + "# x_max = max_x\n", + "\n", + "# # Place the electron hit on the canvas\n", + "# canvas[y_min:y_max, x_min:x_max] = np.clip(\n", + "# canvas[y_min:y_max, x_min:x_max] + hit, 0, 255\n", + "# )\n", + "\n", + "# # Calculate the center coordinates of the hit\n", + "# x_center = x_min + hit.shape[1] // 2\n", + "# y_center = y_min + hit.shape[0] // 2\n", + "\n", + "# # Update centers and centers_training\n", + "# centers.append((x_center, y_center))\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + "\n", + "# # If you want to add noise, uncomment the following lines\n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # Add dark noise\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas += self.dark_noise[noise_int]\n", + "\n", + "# return (canvas, centers, centers_training)\n", + "\n", + "# def generate_multiple_images(self):\n", + "# \"\"\"Generates multiple images with 5 electron hits placed at specified positions.\"\"\" \n", + "# results = []\n", + "# for _ in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + "# results.append(self.place_image_on_canvas())\n", + "# return results\n", + "\n", + "# def generate_noise_only_images(self, num_images):\n", + "# \"\"\"Generates images containing only noise, with no electron hits.\n", + "\n", + "# Args:\n", + "# num_images (int): Number of noise-only images to generate.\n", + "\n", + "# Returns:\n", + "# list: List of generated noise-only images.\n", + "# \"\"\"\n", + "# noise_images = []\n", + "# for _ in tqdm(range(num_images), desc=\"Generating noise-only images\"):\n", + "# # Create an empty canvas\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "\n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # Add dark noise\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas += self.dark_noise[noise_int]\n", + "\n", + "# noise_images.append(canvas)\n", + "\n", + "# return noise_images\n", + "\n", + "# def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + "# \"\"\"Mixes object-containing images with noise-only images and saves to an HDF5 file\n", + "\n", + "# Args:\n", + "# data_with_objects (list): List of data with objects to save.\n", + "# noise_images (list): List of noise-only images to save.\n", + "# filename (str): Path to the HDF5 file.\n", + "# \"\"\"\n", + "# total_images = len(data_with_objects) + len(noise_images)\n", + "# combined_data = []\n", + "\n", + "# # Add labels: 1 for images with objects, 0 for noise-only images\n", + "# for item in data_with_objects:\n", + "# combined_data.append((item[0], item[2], 1)) # 1 indicates it contains objects\n", + "\n", + "# for noise_image in noise_images:\n", + "# combined_data.append((noise_image, np.zeros((self.max_electron_hits, 3)), 0)) # 0 indicates noise-only\n", + "\n", + "# # Shuffle the combined data\n", + "# random.shuffle(combined_data)\n", + "\n", + "# # Save to HDF5 file\n", + "# with h5py.File(filename, 'w') as h5_file:\n", + "# theimages = h5_file.create_dataset('images', shape=(total_images, self.canvas_size[0], self.canvas_size[1]), dtype='uint8')\n", + "# thecenters = h5_file.create_dataset('centers_training', shape=(total_images, self.max_electron_hits, 3), dtype='float32')\n", + "# labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# for i, (image, center, label) in enumerate(combined_data):\n", + "# theimages[i] = image\n", + "# thecenters[i] = center\n", + "# labels[i] = label\n", + "\n", + "# # Paths to your TIFF files\n", + "# tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# # Creating an instance of ImageProcessor with max_electron_hits=5\n", + "# processor = ImageProcessor(\n", + "# num_to_generate=15000, \n", + "# tiff_path=tiff_path, \n", + "# dark_noise_path=dark_noise_path, \n", + "# max_electron_hits=5\n", + "# )\n", + "\n", + "# # Generating images with 5 electron hits placed at specified positions\n", + "# data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# # Generating noise-only images (if needed)\n", + "# noise_only_images = processor.generate_noise_only_images(0) # Change the number if you want noise-only images\n", + "\n", + "# # Save mixed dataset to an HDF5 file\n", + "# processor.save_mixed_images_to_h5(\n", + "# data_with_intensity_range, \n", + "# noise_only_images, \n", + "# '/home/da886/Final Electron counting project/Images and Labels/15KElectronHits_RandomindexCornersAndCenterWithNoise.h5'\n", + "# )\n", + "\n", + "# # Optional: Visual verification\n", + "# # Uncomment the following lines to display one of the generated images\n", + "# import matplotlib.pyplot as plt\n", + "# canvas, centers, centers_training = data_with_intensity_range[0]\n", + "# plt.imshow(canvas, cmap='gray')\n", + "# for center in centers:\n", + "# plt.scatter(center[0], center[1], c='red', marker='x') # Mark the centers\n", + "# plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sod", + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Final Electron counting project/Data Generation for exact center.ipynb b/Final Electron counting project/Data Generation for exact center.ipynb index 7da2e7a..d078fa5 100644 --- a/Final Electron counting project/Data Generation for exact center.ipynb +++ b/Final Electron counting project/Data Generation for exact center.ipynb @@ -49,68 +49,1986 @@ "print(\"device\", device)\n" ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(98000, 19, 19)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tifffile as tiff\n", + "import os\n", + "\n", + "# Load the TIFF stack\n", + "file_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "tiff_stack = tiff.imread(file_path)\n", + "\n", + "# Check the shape of the stack to ensure it is a 3D array\n", + "print(tiff_stack.shape) # (num_slices, height, width)\n", + "\n", + "# Verify the shape\n", + "if len(tiff_stack.shape) != 3:\n", + " raise ValueError(\"The loaded TIFF stack is not a 3D array.\")\n", + "\n", + "# Function to plot multiple slices in a grid\n", + "def plot_slices(start, end):\n", + " fig, axes = plt.subplots(nrows=10, ncols=10, figsize=(15, 15))\n", + " fig.suptitle(f'Slices {start} to {end-1}')\n", + " \n", + " for i, ax in enumerate(axes.flat):\n", + " slice_index = start + i\n", + " if slice_index < end:\n", + " ax.imshow(tiff_stack[slice_index], cmap='gray')\n", + " ax.set_title(f'Slice {slice_index}')\n", + " ax.axis('off')\n", + " else:\n", + " ax.axis('off')\n", + " \n", + " plt.tight_layout()\n", + " plt.subplots_adjust(top=0.95)\n", + " plt.show()\n", + "\n", + "# Plot the first 100 slices\n", + "plot_slices(7899, 7999)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With Random Noisy Images--random hits picked" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating images: 100%|██████████| 200000/200000 [01:13<00:00, 2705.01it/s]\n" + ] + } + ], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# from PIL import Image\n", + "# from tqdm import tqdm\n", + "# import h5py\n", + "\n", + "# class ImageProcessor:\n", + "# \"\"\"Image generation class\"\"\" \n", + " \n", + "# def __init__(self, \n", + "# num_to_generate,\n", + "# tiff_path, \n", + "# dark_noise_path, \n", + "# canvas_size = (64, 64), \n", + "# max_electron_hits = 13):\n", + "# \"\"\"Initializes the ImageProcessor class\n", + "\n", + "# Args:\n", + "# num_to_generate (int): Number of images to generate\n", + "# tiff_path (str): Location of the tiff file that contains the electron hits\n", + "# dark_noise_path (str): Path to the noisy data\n", + "# canvas_size (tuple, optional): Size of the canvas to place the images on. Defaults to (64, 64).\n", + "# max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 272.\n", + "# \"\"\" \n", + " \n", + "# self.tiff_path = tiff_path\n", + "# self.dark_noise_path = dark_noise_path\n", + "# self.canvas_size = canvas_size\n", + "# self.num_to_generate = num_to_generate\n", + "# self.max_electron_hits = max_electron_hits\n", + " \n", + "# # Loads the images from the tiff file\n", + "# self.images = self.load_images_from_tiff(tiff_path)\n", + "# self.dark_noise_images = self.load_images_from_tiff(dark_noise_path)\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + " \n", + "# def load_images_from_tiff(self, tiff_path):\n", + "# \"\"\"Loads the images from a tiff file\n", + "\n", + "# Args:\n", + "# tiff_path (str): Path to the tiff file\n", + "\n", + "# Returns:\n", + "# list: List of images\n", + "# \"\"\" \n", + "# with Image.open(tiff_path) as img:\n", + "# images = []\n", + "# for i in range(img.n_frames):\n", + "# img.seek(i)\n", + "# images.append(np.array(img))\n", + "# return images\n", + " \n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\n", + " \n", + "# Args:\n", + "# noise_typ (str): Type of noise to add\n", + "# image (numpy array): Image to add noise to\n", + " \n", + "# Returns:\n", + "# numpy array: Noisy image\n", + "# \"\"\"\n", + " \n", + "# # if noise_typ == \"gauss\":\n", + "# # row,col,= image.shape\n", + "# # mean = 0 #taken from sparse frames of celeritas histogram . mean = -0.17 .RMSD = 1.319\n", + "# # var = 0.0001 #square of the standard deviation from sparse frames histogram\n", + "# # sigma = var**0.5\n", + "# # threshold = 8 #8ADU\n", + "# # gauss = np.random.normal(mean,sigma,(row,col)) #thresholding instead of adding noise\n", + "# # tnoisy = image + gauss #just making sure they're not exactly the same\n", + "\n", + "# # for x in range(row): #Noise thresholding so that only positive noise is added to the empty pixels\n", + "# # for y in range(col):\n", + "# # #each pixel should be an integer, not a floating point. Round each pixel after noise is added.\n", + "# # if tnoisy[x][y] < threshold: #trying not to wipe out smaller contributions\n", + "# # tnoisy[x][y] = 0\n", + "\n", + "# # noisy = np.round(tnoisy) #+ gauss) #adding noise after thresholding to recreate the image\n", + "# # return noisy\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.0001\n", + "# sigma = var**0.5\n", + "# threshold = 8\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", + "\n", + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\n", + " \n", + "# Args:\n", + "# image (numpy array): Image to correct\n", + "# \"\"\" \n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\n", + " \n", + "# Args:\n", + "# imgsize (int): Size of the images in the stack\n", + "# \"\"\" \n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + " \n", + "# # def place_image_on_canvas(self, positions=3, intensity_range=(10, 255)):\n", + "# def place_image_on_canvas(self, positions=3):\n", + "# \"\"\"Places the electron hits on the canvas without specifying intensity range.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "# height, width = self.images[0].shape\n", + "# max_x = self.canvas_size[1]\n", + "# max_y = self.canvas_size[0]\n", + "# bounding_boxes = []\n", + "# centers = []\n", + "# index_ = []\n", + "# bounding_boxes_training = np.zeros((self.max_electron_hits, 5), dtype=np.float32)\n", + "# centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + " \n", + "# for i in range(positions):\n", + "# # Randomly select an electron hit\n", + "# index = random.randint(0, len(self.images) - 1)\n", + "# hit = self.images[index]\n", + " \n", + "# # Random position for placing the electron hit\n", + "# x = random.randint(0, max_x - width)\n", + "# y = random.randint(0, max_y - height)\n", + "\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + "\n", + "# # Calculate the exact center based on pixel intensity\n", + "# total_intensity = np.sum(hit)\n", + "# if total_intensity > 0:\n", + "# y_coords, x_coords = np.indices(hit.shape)\n", + "# x_center = x + np.sum(x_coords * hit) / total_intensity\n", + "# y_center = y + np.sum(y_coords * hit) / total_intensity\n", + "# else:\n", + "# x_center = x + width / 2\n", + "# y_center = y + height / 2\n", + " \n", + "# canvas[y_min:y_max, x_min:x_max] = hit\n", + "# bounding_boxes.append((x_center-1, y_center-1, x_center+1, y_center+1))\n", + "# bounding_boxes_training[i, 0] = 1\n", + "# bounding_boxes_training[i, 1:] = [x_center-1, y_center-1, x_center+1, y_center+1]\n", + "# centers.append((x_center, y_center))\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + "# index_.append(index)\n", + " \n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas = canvas + self.dark_noise[noise_int]\n", + " \n", + "# return (canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions, noise_int)\n", + "\n", + "\n", + " \n", + "# #### USE THIS BLOCK TO GENERATE FIXED SET\n", + "# # #def generate_multiple_images(self, intensity_range=(10, 255)):\n", + "# # def generate_multiple_images(self, intensity_range=(200, 255)):\n", + "# # \"\"\"Generates multiple images with specified intensity range for the objects.\"\"\" \n", + "# # results = []\n", + "# # for i in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + "# # results.append(self.place_image_on_canvas(positions=3, intensity_range=intensity_range))\n", + "# # return results\n", + " \n", + "# #### USE THIS BLOCK TO GENERATE PADDED SET\n", + "# def generate_multiple_images(self):\n", + "# \"\"\"Generates multiple images without specifying intensity range for the objects.\"\"\" \n", + "# results = []\n", + "# for i in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + "# positions = random.randint(13, self.max_electron_hits)\n", + "# results.append(self.place_image_on_canvas(positions))\n", + "# return results\n", + "\n", + " \n", + "# def generate_noise_only_images(self, num_images):\n", + "# \"\"\"Generates images containing only noise, with no electron hits.\n", + "\n", + "# Args:\n", + "# num_images (int): Number of noise-only images to generate.\n", + "\n", + "# Returns:\n", + "# list: List of generated noise-only images.\n", + "# \"\"\"\n", + "# noise_images = []\n", + "# for _ in tqdm(range(num_images), desc=\"Generating noise-only images\"):\n", + "# # Create an empty canvas\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "\n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # Add dark noise\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas = canvas + self.dark_noise[noise_int]\n", + "\n", + "# noise_images.append(canvas)\n", + "\n", + "# return noise_images\n", + " \n", + " \n", + "\n", + "# # def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + "# # \"\"\"Mixes object-containing images with noise-only images and saves to an HDF5 file\n", + " \n", + "# # Args:\n", + "# # data_with_objects (list): List of data with objects to save.\n", + "# # noise_images (list): List of noise-only images to save.\n", + "# # filename (str): Path to the HDF5 file.\n", + "# # \"\"\"\n", + "# # total_images = len(data_with_objects) + len(noise_images)\n", + "# # combined_data = []\n", + "\n", + "# # # Add labels: 1 for images with objects, 0 for noise-only images\n", + "# # for item in data_with_objects:\n", + "# # combined_data.append((item[0], item[4], 1)) # 1 indicates it contains objects\n", + " \n", + "# # for noise_image in noise_images:\n", + "# # combined_data.append((noise_image, np.zeros((13, 3)), 0)) # 0 indicates noise-only\n", + " \n", + "# # # Shuffle the combined data\n", + "# # random.shuffle(combined_data)\n", + "\n", + "# # # Save to HDF5 file\n", + "# # with h5py.File(filename, 'w') as h5_file:\n", + "# # theimages = h5_file.create_dataset('images', shape=(total_images, 64, 64), dtype='uint8')\n", + "# # thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 13, 3), dtype='float32')\n", + "# # labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# # for i, (image, center, label) in enumerate(combined_data):\n", + "# # theimages[i] = image\n", + "# # thecenters[i] = center\n", + "# # labels[i] = label\n", + " \n", + "# def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + "# \"\"\"Saves object-containing images to an HDF5 file.\n", + "\n", + "# Args:\n", + "# data_with_objects (list): List of data with objects to save.\n", + "# filename (str): Path to the HDF5 file.\n", + "# \"\"\"\n", + "# total_images = len(data_with_objects) # Only count object-containing images now\n", + "# combined_data = []\n", + "\n", + "# # Add labels: 1 for images with objects\n", + "# for item in data_with_objects:\n", + "# combined_data.append((item[0], item[4], 1)) # 1 indicates it contains objects\n", + " \n", + "# # Save to HDF5 file\n", + "# with h5py.File(filename, 'w') as h5_file:\n", + "# theimages = h5_file.create_dataset('images', shape=(total_images, 64, 64), dtype='uint8')\n", + "# thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 13, 3), dtype='float32')\n", + "# labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# for i, (image, center, label) in enumerate(combined_data):\n", + "# theimages[i] = image\n", + "# thecenters[i] = center\n", + "# labels[i] = label\n", + "\n", + "\n", + "\n", + "# tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# # Creating an instance of ImageProcessor\n", + "# processor = ImageProcessor(200000, tiff_path, dark_noise_path, max_electron_hits=13)\n", + "\n", + "# # Generating images with objects \n", + "# # data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# # Generating noise-only images\n", + "# # noise_only_images = processor.generate_noise_only_images(100000)\n", + "\n", + "# # Save mixed dataset to an HDF5 file\n", + "# # processor.save_mixed_images_to_h5(data_with_intensity_range, noise_only_images, '/home/da886/Final Electron counting project/Images and Labels/1milFixed_Mixed_13.h5')\n", + "\n", + "\n", + "# # Generating images with objects \n", + "# data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# # Save only object-containing images to an HDF5 file\n", + "# processor.save_mixed_images_to_h5(data_with_intensity_range, [], '/home/da886/Final Electron counting project/Images and Labels/200KFixed_13.h5')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "specific index picked" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# from PIL import Image\n", + "# from tqdm import tqdm\n", + "# import h5py\n", + "\n", + "# class ImageProcessor:\n", + "# \"\"\"Image generation class\"\"\" \n", + " \n", + "# def __init__(self, \n", + "# num_to_generate,\n", + "# tiff_path, \n", + "# dark_noise_path, \n", + "# canvas_size = (64, 64), \n", + "# max_electron_hits = 13):\n", + "# \"\"\"Initializes the ImageProcessor class\n", + "\n", + "# Args:\n", + "# num_to_generate (int): Number of images to generate\n", + "# tiff_path (str): Location of the tiff file that contains the electron hits\n", + "# dark_noise_path (str): Path to the noisy data\n", + "# canvas_size (tuple, optional): Size of the canvas to place the images on. Defaults to (64, 64).\n", + "# max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 272.\n", + "# \"\"\" \n", + " \n", + "# self.tiff_path = tiff_path\n", + "# self.dark_noise_path = dark_noise_path\n", + "# self.canvas_size = canvas_size\n", + "# self.num_to_generate = num_to_generate\n", + "# self.max_electron_hits = max_electron_hits\n", + " \n", + "# # Loads the images from the tiff file\n", + "# self.images = self.load_images_from_tiff(tiff_path)\n", + "# self.dark_noise_images = self.load_images_from_tiff(dark_noise_path)\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + " \n", + "# def load_images_from_tiff(self, tiff_path):\n", + "# \"\"\"Loads the images from a tiff file\n", + "\n", + "# Args:\n", + "# tiff_path (str): Path to the tiff file\n", + "\n", + "# Returns:\n", + "# list: List of images\n", + "# \"\"\" \n", + "# with Image.open(tiff_path) as img:\n", + "# images = []\n", + "# for i in range(img.n_frames):\n", + "# img.seek(i)\n", + "# images.append(np.array(img))\n", + "# return images\n", + " \n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\n", + " \n", + "# Args:\n", + "# noise_typ (str): Type of noise to add\n", + "# image (numpy array): Image to add noise to\n", + " \n", + "# Returns:\n", + "# numpy array: Noisy image\n", + "# \"\"\"\n", + " \n", + "# # if noise_typ == \"gauss\":\n", + "# # row,col,= image.shape\n", + "# # mean = 0 #taken from sparse frames of celeritas histogram . mean = -0.17 .RMSD = 1.319\n", + "# # var = 0.0001 #square of the standard deviation from sparse frames histogram\n", + "# # sigma = var**0.5\n", + "# # threshold = 8 #8ADU\n", + "# # gauss = np.random.normal(mean,sigma,(row,col)) #thresholding instead of adding noise\n", + "# # tnoisy = image + gauss #just making sure they're not exactly the same\n", + "\n", + "# # for x in range(row): #Noise thresholding so that only positive noise is added to the empty pixels\n", + "# # for y in range(col):\n", + "# # #each pixel should be an integer, not a floating point. Round each pixel after noise is added.\n", + "# # if tnoisy[x][y] < threshold: #trying not to wipe out smaller contributions\n", + "# # tnoisy[x][y] = 0\n", + "\n", + "# # noisy = np.round(tnoisy) #+ gauss) #adding noise after thresholding to recreate the image\n", + "# # return noisy\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.0001\n", + "# sigma = var**0.5\n", + "# threshold = 8\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", + "\n", + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\n", + " \n", + "# Args:\n", + "# image (numpy array): Image to correct\n", + "# \"\"\" \n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\n", + " \n", + "# Args:\n", + "# imgsize (int): Size of the images in the stack\n", + "# \"\"\" \n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + " \n", + "# # def place_image_on_canvas(self, positions=3, intensity_range=(10, 255)):\n", + " # def place_image_on_canvas(self, positions=3):\n", + " # \"\"\"Places the electron hits on the canvas using a fixed index.\"\"\"\n", + " # canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + " # height, width = self.images[0].shape\n", + " # max_x = self.canvas_size[1]\n", + " # max_y = self.canvas_size[0]\n", + " # bounding_boxes = []\n", + " # centers = []\n", + " # index_ = []\n", + " # bounding_boxes_training = np.zeros((self.max_electron_hits, 5), dtype=np.float32)\n", + " # centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + " \n", + " # for i in range(positions):\n", + " # # Use the fixed index 6 for the electron hit\n", + " # index = 6\n", + " # hit = self.images[index]\n", + " \n", + " # # Random position for placing the electron hit\n", + " # x = random.randint(0, max_x - width)\n", + " # y = random.randint(0, max_y - height)\n", + "\n", + " # y_min = y\n", + " # y_max = y + height\n", + " # x_min = x \n", + " # x_max = x + width\n", + "\n", + " # # Calculate the exact center based on pixel intensity\n", + " # total_intensity = np.sum(hit)\n", + " # if total_intensity > 0:\n", + " # y_coords, x_coords = np.indices(hit.shape)\n", + " # x_center = x + np.sum(x_coords * hit) / total_intensity\n", + " # y_center = y + np.sum(y_coords * hit) / total_intensity\n", + " # else:\n", + " # x_center = x + width / 2\n", + " # y_center = y + height / 2\n", + " \n", + " # canvas[y_min:y_max, x_min:x_max] = hit\n", + " # bounding_boxes.append((x_center-1, y_center-1, x_center+1, y_center+1))\n", + " # bounding_boxes_training[i, 0] = 1\n", + " # bounding_boxes_training[i, 1:] = [x_center-1, y_center-1, x_center+1, y_center+1]\n", + " # centers.append((x_center, y_center))\n", + " # centers_training[i, 0] = 1\n", + " # centers_training[i, 1:] = [x_center, y_center]\n", + " # index_.append(index)\n", + " \n", + " # # Apply Gaussian noise\n", + " # canvas = self.noisy('gauss', canvas)\n", + " # noise_int = np.random.randint(len(self.dark_noise))\n", + " # canvas = canvas + self.dark_noise[noise_int]\n", + " \n", + " # return (canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions, noise_int)\n", + "\n", + "# # return (canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions)\n", + "\n", + " \n", + "# #### USE THIS BLOCK TO GENERATE FIXED SET\n", + "# # #def generate_multiple_images(self, intensity_range=(10, 255)):\n", + "# # def generate_multiple_images(self, intensity_range=(200, 255)):\n", + "# # \"\"\"Generates multiple images with specified intensity range for the objects.\"\"\" \n", + "# # results = []\n", + "# # for i in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + "# # results.append(self.place_image_on_canvas(positions=3, intensity_range=intensity_range))\n", + "# # return results\n", + " \n", + "# #### USE THIS BLOCK TO GENERATE PADDED SET\n", + "# def generate_multiple_images(self):\n", + "# \"\"\"Generates multiple images without specifying intensity range for the objects.\"\"\" \n", + "# results = []\n", + "# for i in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + "# positions = random.randint(13, self.max_electron_hits)\n", + "# results.append(self.place_image_on_canvas(positions))\n", + "# return results\n", + "\n", + " \n", + "# def generate_noise_only_images(self, num_images):\n", + "# \"\"\"Generates images containing only noise, with no electron hits.\n", + "\n", + "# Args:\n", + "# num_images (int): Number of noise-only images to generate.\n", + "\n", + "# Returns:\n", + "# list: List of generated noise-only images.\n", + "# \"\"\"\n", + "# noise_images = []\n", + "# for _ in tqdm(range(num_images), desc=\"Generating noise-only images\"):\n", + "# # Create an empty canvas\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "\n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # Add dark noise\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas = canvas + self.dark_noise[noise_int]\n", + "\n", + "# noise_images.append(canvas)\n", + "\n", + "# return noise_images\n", + " \n", + " \n", + "\n", + "# # def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + "# # \"\"\"Mixes object-containing images with noise-only images and saves to an HDF5 file\n", + " \n", + "# # Args:\n", + "# # data_with_objects (list): List of data with objects to save.\n", + "# # noise_images (list): List of noise-only images to save.\n", + "# # filename (str): Path to the HDF5 file.\n", + "# # \"\"\"\n", + "# # total_images = len(data_with_objects) + len(noise_images)\n", + "# # combined_data = []\n", + "\n", + "# # # Add labels: 1 for images with objects, 0 for noise-only images\n", + "# # for item in data_with_objects:\n", + "# # combined_data.append((item[0], item[4], 1)) # 1 indicates it contains objects\n", + " \n", + "# # for noise_image in noise_images:\n", + "# # combined_data.append((noise_image, np.zeros((13, 3)), 0)) # 0 indicates noise-only\n", + " \n", + "# # # Shuffle the combined data\n", + "# # random.shuffle(combined_data)\n", + "\n", + "# # # Save to HDF5 file\n", + "# # with h5py.File(filename, 'w') as h5_file:\n", + "# # theimages = h5_file.create_dataset('images', shape=(total_images, 64, 64), dtype='uint8')\n", + "# # thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 13, 3), dtype='float32')\n", + "# # labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# # for i, (image, center, label) in enumerate(combined_data):\n", + "# # theimages[i] = image\n", + "# # thecenters[i] = center\n", + "# # labels[i] = label\n", + " \n", + "# def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + "# \"\"\"Saves object-containing images to an HDF5 file.\n", + "\n", + "# Args:\n", + "# data_with_objects (list): List of data with objects to save.\n", + "# filename (str): Path to the HDF5 file.\n", + "# \"\"\"\n", + "# total_images = len(data_with_objects) # Only count object-containing images now\n", + "# combined_data = []\n", + "\n", + "# # Add labels: 1 for images with objects\n", + "# for item in data_with_objects:\n", + "# combined_data.append((item[0], item[4], 1)) # 1 indicates it contains objects\n", + " \n", + "# # Save to HDF5 file\n", + "# with h5py.File(filename, 'w') as h5_file:\n", + "# theimages = h5_file.create_dataset('images', shape=(total_images, 64, 64), dtype='uint8')\n", + "# thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 13, 3), dtype='float32')\n", + "# labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# for i, (image, center, label) in enumerate(combined_data):\n", + "# theimages[i] = image\n", + "# thecenters[i] = center\n", + "# labels[i] = label\n", + "\n", + "\n", + "\n", + "# tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# # Creating an instance of ImageProcessor\n", + "# processor = ImageProcessor(500, tiff_path, dark_noise_path, max_electron_hits=13)\n", + "\n", + "# # Generating images with objects \n", + "# # data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# # Generating noise-only images\n", + "# # noise_only_images = processor.generate_noise_only_images(100000)\n", + "\n", + "# # Save mixed dataset to an HDF5 file\n", + "# # processor.save_mixed_images_to_h5(data_with_intensity_range, noise_only_images, '/home/da886/Final Electron counting project/Images and Labels/1milFixed_Mixed_13.h5')\n", + "\n", + "\n", + "# # Generating images with objects \n", + "# data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# # Save only object-containing images to an HDF5 file\n", + "# processor.save_mixed_images_to_h5(data_with_intensity_range, [], '/home/da886/Final Electron counting project/Images and Labels/500AnalysisFixed-index6_13.h5')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# import matplotlib.pyplot as plt\n", + "# import tifffile as tiff\n", + "# from tqdm import tqdm\n", + "\n", + "# # Load the TIFF stacks for electron hits and dark noise\n", + "# electron_tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# electron_hits_stack = tiff.imread(electron_tiff_path)\n", + "# dark_noise_stack = tiff.imread(dark_noise_path)\n", + "\n", + "# # Define the ImageProcessor class\n", + "# class ImageProcessor:\n", + "# def __init__(self, tiff_stack, dark_noise_stack, canvas_size=(64, 64), max_electron_hits=13):\n", + "# \"\"\"Initializes the ImageProcessor class\"\"\"\n", + "# self.images = tiff_stack\n", + "# self.dark_noise_images = dark_noise_stack\n", + "# self.canvas_size = canvas_size\n", + "# self.max_electron_hits = max_electron_hits\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + "\n", + "# def load_images_from_tiff(self, tiff_path):\n", + "# \"\"\"Loads the images from a tiff file\"\"\"\n", + "# with Image.open(tiff_path) as img:\n", + "# images = []\n", + "# for i in range(img.n_frames):\n", + "# img.seek(i)\n", + "# images.append(np.array(img))\n", + "# return images\n", + "\n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\"\"\"\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.001 # Increase or decrease this for more or less noise\n", + "# sigma = var ** 0.5\n", + "# threshold = 8 # Adjust this as necessary\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\"\"\"\n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\"\"\"\n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self, positions=3):\n", + "# \"\"\"Places the electron hits on the canvas and adds noise.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "# height, width = self.images[0].shape\n", + "# max_x = self.canvas_size[1]\n", + "# max_y = self.canvas_size[0]\n", + "# bounding_boxes = []\n", + "# centers = []\n", + "# index_ = []\n", + "# bounding_boxes_training = np.zeros((self.max_electron_hits, 5), dtype=np.float32)\n", + "# centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + "\n", + "# for i in range(positions):\n", + "# # Use the fixed index 6 for the electron hit\n", + "# index = 6\n", + "# hit = self.images[index]\n", + "\n", + "# # Random position for placing the electron hit\n", + "# x = random.randint(0, max_x - width)\n", + "# y = random.randint(0, max_y - height)\n", + "\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + "\n", + "# # Calculate the exact center based on pixel intensity\n", + "# total_intensity = np.sum(hit)\n", + "# if total_intensity > 0:\n", + "# y_coords, x_coords = np.indices(hit.shape)\n", + "# x_center = x + np.sum(x_coords * hit) / total_intensity\n", + "# y_center = y + np.sum(y_coords * hit) / total_intensity\n", + "# else:\n", + "# x_center = x + width / 2\n", + "# y_center = y + height / 2\n", + "\n", + "# canvas[y_min:y_max, x_min:x_max] = hit\n", + "# bounding_boxes.append((x_center-1, y_center-1, x_center+1, y_center+1))\n", + "# bounding_boxes_training[i, 0] = 1\n", + "# bounding_boxes_training[i, 1:] = [x_center-1, y_center-1, x_center+1, y_center+1]\n", + "# centers.append((x_center, y_center))\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + "# index_.append(index)\n", + "\n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # Apply dark noise\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas = canvas + self.dark_noise[noise_int]\n", + "\n", + "# return (canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions)\n", + "\n", + "# # Create an instance of ImageProcessor\n", + "# processor = ImageProcessor(electron_hits_stack, dark_noise_stack)\n", + "\n", + "# # Generate 20 images with exactly 10 spots on each image\n", + "# generated_images_with_noise = []\n", + "# centers_list_with_noise = []\n", + "\n", + "# for _ in range(20):\n", + "# canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions = processor.place_image_on_canvas(positions=10)\n", + "# generated_images_with_noise.append(canvas)\n", + "# centers_list_with_noise.append(centers)\n", + "\n", + "# # Plot these generated images with the centers labeled\n", + "# fig, axes = plt.subplots(4, 5, figsize=(15, 12))\n", + "\n", + "# for i, ax in enumerate(axes.flat):\n", + "# ax.imshow(generated_images_with_noise[i], cmap='gray')\n", + "# for j, center in enumerate(centers_list_with_noise[i]):\n", + "# ax.plot(center[0], center[1], 'rx') # Marking the center with a red 'x'\n", + "# # Adding labels to each spot (e.g., index number of the spot)\n", + "# ax.text(center[0], center[1], f\"{j+1}\", color='white', fontsize=12, ha='center', va='center')\n", + "# ax.set_title(f'Image {i+1} with 10 Spots and Noise')\n", + "# ax.axis('off')\n", + "\n", + "# plt.tight_layout()\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Images without Noise" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# import matplotlib.pyplot as plt\n", + "# import tifffile as tiff\n", + "# from tqdm import tqdm\n", + "\n", + "# # Load the TIFF stacks for electron hits and dark noise\n", + "# electron_tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "\n", + "\n", + "# electron_hits_stack = tiff.imread(electron_tiff_path)\n", + "# dark_noise_stack = tiff.imread(dark_noise_path)\n", + "\n", + "# # Adjust the dark noise intensity scaling and generate new images\n", + "\n", + "# class ImageProcessor:\n", + "# def __init__(self, tiff_stack, dark_noise_stack, canvas_size=(64, 64), max_electron_hits=13):\n", + "# \"\"\"Initializes the ImageProcessor class\"\"\"\n", + "# self.images = tiff_stack\n", + "# self.dark_noise_images = dark_noise_stack\n", + "# self.canvas_size = canvas_size\n", + "# self.max_electron_hits = max_electron_hits\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + "\n", + "# def noisy(self, noise_typ, image):\n", + "# if noise_typ == \"gauss\":\n", + "# row,col,= image.shape\n", + "# mean = 0 #taken from sparse frames of celeritas histogram . mean = -0.17 .RMSD = 1.319\n", + "# var = 0.0001 #square of the standard deviation from sparse frames histogram\n", + "# sigma = var**0.5\n", + "# threshold = 8 #8ADU\n", + "# gauss = np.random.normal(mean,sigma,(row,col)) #thresholding instead of adding noise\n", + "# tnoisy = image + gauss #just making sure they're not exactly the same\n", + "\n", + "# for x in range(row): #Noise thresholding so that only positive noise is added to the empty pixels\n", + "# for y in range(col):\n", + "# #each pixel should be an integer, not a floating point. Round each pixel after noise is added.\n", + "# if tnoisy[x][y] < threshold: #trying not to wipe out smaller contributions\n", + "# tnoisy[x][y] = 0\n", + "\n", + "# noisy = np.round(tnoisy) #+ gauss) #adding noise after thresholding to recreate the image\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\"\"\"\n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\"\"\"\n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self, positions=3):\n", + "# \"\"\"Places the electron hits on the canvas using a fixed index.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.float32) # Use float32 for better precision\n", + "# height, width = self.images[0].shape\n", + "# max_x = self.canvas_size[1]\n", + "# max_y = self.canvas_size[0]\n", + "# bounding_boxes = []\n", + "# centers = []\n", + "# index_ = []\n", + "# bounding_boxes_training = np.zeros((self.max_electron_hits, 5), dtype=np.float32)\n", + "# centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + "\n", + "# for i in range(positions):\n", + "# # Use the fixed index 6 for the electron hit\n", + "# index = 6\n", + "# hit = self.images[index] * 20 # Increase the intensity of the electron hit\n", + " \n", + "# # Random position for placing the electron hit\n", + "# x = random.randint(0, max_x - width)\n", + "# y = random.randint(0, max_y - height)\n", + "\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x\n", + "# x_max = x + width\n", + "\n", + "# # Calculate the exact center based on pixel intensity\n", + "# total_intensity = np.sum(hit)\n", + "# if total_intensity > 0:\n", + "# y_coords, x_coords = np.indices(hit.shape)\n", + "# x_center = x + np.sum(x_coords * hit) / total_intensity\n", + "# y_center = y + np.sum(y_coords * hit) / total_intensity\n", + "# else:\n", + "# x_center = x + width / 2\n", + "# y_center = y + height / 2\n", + "\n", + "# canvas[y_min:y_max, x_min:x_max] = np.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255) # Prevent overlap overflow\n", + "# bounding_boxes.append((x_center - 1, y_center - 1, x_center + 1, y_center + 1))\n", + "# bounding_boxes_training[i, 0] = 1\n", + "# bounding_boxes_training[i, 1:] = [x_center - 1, y_center - 1, x_center + 1, y_center + 1]\n", + "# centers.append((x_center, y_center))\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + "# index_.append(index)\n", + "\n", + "# # Convert back to uint8 for display purposes\n", + "# canvas = np.clip(canvas, 0, 255).astype(np.uint8)\n", + " \n", + "# return (canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions)\n", + "\n", + "\n", + "\n", + "# # Create an instance of ImageProcessor\n", + "# processor = ImageProcessor(electron_hits_stack, dark_noise_stack)\n", + "\n", + "# # Generate 10 images with exactly 10 spots on each image\n", + "# generated_images_with_noise_scaled = []\n", + "# centers_list_with_noise_scaled = []\n", + "\n", + "# for _ in range(6):\n", + "# canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions = processor.place_image_on_canvas(positions=10)\n", + "# generated_images_with_noise_scaled.append(canvas)\n", + "# centers_list_with_noise_scaled.append(centers)\n", + "\n", + "# # Plot these generated images without the labels on the spots\n", + "# fig, axes = plt.subplots(2, 3, figsize=(15, 6))\n", + "\n", + "# for i, ax in enumerate(axes.flat):\n", + "# ax.imshow(generated_images_with_noise_scaled[i], cmap='gray')\n", + "# for center in centers_list_with_noise_scaled[i]:\n", + "# ax.plot(center[0], center[1], 'rx') # Marking the center with a red 'x'\n", + "# ax.set_title(f'Image {i+1} with 10 Spots and Scaled Noise')\n", + "# ax.axis('off')\n", + "\n", + "# plt.tight_layout()\n", + "# plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (0,0) (19,19) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[146], line 142\u001b[0m\n\u001b[1;32m 139\u001b[0m centers_list_with_noise_scaled \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 141\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m6\u001b[39m):\n\u001b[0;32m--> 142\u001b[0m canvas, centers, centers_training, index_, positions \u001b[38;5;241m=\u001b[39m \u001b[43mprocessor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplace_image_on_canvas\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpositions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m13\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 143\u001b[0m generated_images_with_noise_scaled\u001b[38;5;241m.\u001b[39mappend(canvas)\n\u001b[1;32m 144\u001b[0m centers_list_with_noise_scaled\u001b[38;5;241m.\u001b[39mappend(centers)\n", + "Cell \u001b[0;32mIn[146], line 110\u001b[0m, in \u001b[0;36mImageProcessor.place_image_on_canvas\u001b[0;34m(self, positions)\u001b[0m\n\u001b[1;32m 108\u001b[0m x_center \u001b[38;5;241m=\u001b[39m x \u001b[38;5;241m+\u001b[39m width \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[1;32m 109\u001b[0m y_center \u001b[38;5;241m=\u001b[39m y \u001b[38;5;241m+\u001b[39m height \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[0;32m--> 110\u001b[0m canvas[y_min:y_max, x_min:x_max] \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mclip(\u001b[43mcanvas\u001b[49m\u001b[43m[\u001b[49m\u001b[43my_min\u001b[49m\u001b[43m:\u001b[49m\u001b[43my_max\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx_min\u001b[49m\u001b[43m:\u001b[49m\u001b[43mx_max\u001b[49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mhit\u001b[49m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m255\u001b[39m)\n\u001b[1;32m 111\u001b[0m \u001b[38;5;66;03m# bounding_boxes.append((x_center - 1, y_center - 1, x_center + 1, y_center + 1))\u001b[39;00m\n\u001b[1;32m 112\u001b[0m \u001b[38;5;66;03m# bounding_boxes_training[i, 0] = 1\u001b[39;00m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;66;03m# bounding_boxes_training[i, 1:] = [x_center - 1, y_center - 1, x_center + 1, y_center + 1]\u001b[39;00m\n\u001b[1;32m 114\u001b[0m centers\u001b[38;5;241m.\u001b[39mappend((x_center, y_center))\n", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (0,0) (19,19) " + ] + } + ], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# import matplotlib.pyplot as plt\n", + "# import tifffile as tiff\n", + "# from tqdm import tqdm\n", + "\n", + "# # Load the TIFF stacks for electron hits and dark noise\n", + "# electron_tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "\n", + "\n", + "# electron_hits_stack = tiff.imread(electron_tiff_path)\n", + "# dark_noise_stack = tiff.imread(dark_noise_path)\n", + "\n", + "# # Adjust the dark noise intensity scaling and generate new images\n", + "\n", + "# class ImageProcessor:\n", + "# def __init__(self, tiff_stack, dark_noise_stack, canvas_size=(64, 64), max_electron_hits=13):\n", + "# \"\"\"Initializes the ImageProcessor class\"\"\"\n", + "# self.images = tiff_stack\n", + "# self.dark_noise_images = dark_noise_stack\n", + "# self.canvas_size = canvas_size\n", + "# self.max_electron_hits = max_electron_hits\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + "\n", + "# def noisy(self, noise_typ, image):\n", + "# if noise_typ == \"gauss\":\n", + "# row,col,= image.shape\n", + "# mean = 0 #taken from sparse frames of celeritas histogram . mean = -0.17 .RMSD = 1.319\n", + "# var = 0.0001 #square of the standard deviation from sparse frames histogram\n", + "# sigma = var**0.5\n", + "# threshold = 8 #8ADU\n", + "# gauss = np.random.normal(mean,sigma,(row,col)) #thresholding instead of adding noise\n", + "# tnoisy = image + gauss #just making sure they're not exactly the same\n", + "\n", + "# for x in range(row): #Noise thresholding so that only positive noise is added to the empty pixels\n", + "# for y in range(col):\n", + "# #each pixel should be an integer, not a floating point. Round each pixel after noise is added.\n", + "# if tnoisy[x][y] < threshold: #trying not to wipe out smaller contributions\n", + "# tnoisy[x][y] = 0\n", + "\n", + "# noisy = np.round(tnoisy) #+ gauss) #adding noise after thresholding to recreate the image\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\"\"\"\n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\"\"\"\n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self, positions=3):\n", + "# \"\"\"Places the electron hits on the canvas and adds noise.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.float32) # Use float32 for better precision\n", + "# height, width = self.images[0].shape\n", + "# max_x = self.canvas_size[1]\n", + "# max_y = self.canvas_size[0]\n", + "# # bounding_boxes = []\n", + "# centers = []\n", + "# index_ = []\n", + "# # bounding_boxes_training = np.zeros((self.max_electron_hits, 5), dtype=np.float32)\n", + "# centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + "\n", + "# for i in range(positions):\n", + "# x = random.randint(1 - width//2, max_x - width//2 - 1)\n", + "# y = random.randint(1 - height//2, max_y - height//2 - 1)\n", + "# index = 95\n", + "# hit = self.images[index]\n", + "\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + " \n", + "# x_center = x + width / 2 \n", + "# y_center = y + height / 2\n", + " \n", + "# # if y_min < 0:\n", + "# # hit = hit[y_min*-1:, :]\n", + "# # y_min = 0\n", + "\n", + "# # if y_max > max_y:\n", + "# # hit = hit[:-(y_max-max_y), :]\n", + "# # y_max = max_y\n", + " \n", + "# # if x_min < 0:\n", + "# # hit = hit[:, x_min*-1:]\n", + "# # x_min = 0\n", + " \n", + "# # if x_max > max_x:\n", + "# # hit = hit[:, :-(x_max-max_x)]\n", + "# # x_max = max_x\n", + "# # Calculate the exact center based on pixel intensity\n", + "# total_intensity = np.sum(hit)\n", + "# if total_intensity > 0:\n", + "# y_coords, x_coords = np.indices(hit.shape)\n", + "# x_center = x + np.sum(x_coords * hit) / total_intensity\n", + "# y_center = y + np.sum(y_coords * hit) / total_intensity\n", + "# else:\n", + "# x_center = x + width / 2\n", + "# y_center = y + height / 2\n", + "# canvas[y_min:y_max, x_min:x_max] = np.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255)\n", + "# # bounding_boxes.append((x_center - 1, y_center - 1, x_center + 1, y_center + 1))\n", + "# # bounding_boxes_training[i, 0] = 1\n", + "# # bounding_boxes_training[i, 1:] = [x_center - 1, y_center - 1, x_center + 1, y_center + 1]\n", + "# centers.append((x_center, y_center))\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + "# index_.append(index)\n", + "\n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # # Apply scaled down dark noise\n", + "# # noise_int = np.random.randint(len(self.dark_noise))\n", + "# # canvas = canvas + self.dark_noise[noise_int] # Scaling down dark noise\n", + "\n", + "# # Clip values to valid range for display\n", + "# canvas = np.clip(canvas, 0, 255).astype(np.uint8)\n", + " \n", + "# # return (canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions)\n", + "# return (canvas, centers, centers_training, index_, positions)\n", + "\n", + "\n", + "\n", + "# # Create an instance of ImageProcessor\n", + "# processor = ImageProcessor(electron_hits_stack, dark_noise_stack)\n", + "\n", + "# # Generate 10 images with exactly 10 spots on each image\n", + "# generated_images_with_noise_scaled = []\n", + "# centers_list_with_noise_scaled = []\n", + "\n", + "# for _ in range(6):\n", + "# canvas, centers, centers_training, index_, positions = processor.place_image_on_canvas(positions=13)\n", + "# generated_images_with_noise_scaled.append(canvas)\n", + "# centers_list_with_noise_scaled.append(centers)\n", + "\n", + "# # Plot these generated images without the labels on the spots\n", + "# fig, axes = plt.subplots(2, 3, figsize=(15, 6))\n", + "\n", + "# for i, ax in enumerate(axes.flat):\n", + "# ax.imshow(generated_images_with_noise_scaled[i], cmap='gray')\n", + "# for center in centers_list_with_noise_scaled[i]:\n", + "# ax.plot(center[0], center[1], 'ro', markersize=2) # Adjust the marker size (e.g., 8)\n", + "# ax.set_title(f'Image {i+1} with 10 Spots and Scaled Noise')\n", + "# ax.axis('off')\n", + "\n", + "# plt.tight_layout()\n", + "# plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating images: 100%|██████████| 30000/30000 [00:09<00:00, 3196.42it/s]\n" + ] + } + ], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# from PIL import Image\n", + "# from tqdm import tqdm\n", + "# import h5py\n", + "\n", + "# class ImageProcessor:\n", + "# \"\"\"Image generation class\"\"\" \n", + " \n", + "# def __init__(self, num_to_generate, tiff_path, dark_noise_path, canvas_size=(64, 64), max_electron_hits=13):\n", + "# \"\"\"Initializes the ImageProcessor class\"\"\"\n", + "# self.tiff_path = tiff_path\n", + "# self.dark_noise_path = dark_noise_path\n", + "# self.canvas_size = canvas_size\n", + "# self.num_to_generate = num_to_generate\n", + "# self.max_electron_hits = max_electron_hits\n", + " \n", + "# # Loads the images from the tiff file\n", + "# self.images = self.load_images_from_tiff(tiff_path)\n", + "# self.dark_noise_images = self.load_images_from_tiff(dark_noise_path)\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + " \n", + "# def load_images_from_tiff(self, tiff_path):\n", + "# \"\"\"Loads the images from a tiff file\"\"\"\n", + "# with Image.open(tiff_path) as img:\n", + "# images = []\n", + "# for i in range(img.n_frames):\n", + "# img.seek(i)\n", + "# images.append(np.array(img))\n", + "# return images\n", + " \n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\"\"\"\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.0001\n", + "# sigma = var ** 0.5\n", + "# threshold = 8\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", + "\n", + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\"\"\"\n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\"\"\"\n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self, positions=3):\n", + " \n", + "# \"\"\"Places the electron hits on the canvas without specifying intensity range.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "# height, width = self.images[0].shape\n", + "# max_x = self.canvas_size[1]\n", + "# max_y = self.canvas_size[0]\n", + "# bounding_boxes = []\n", + "# centers = []\n", + "# index_ = []\n", + "# bounding_boxes_training = np.zeros((self.max_electron_hits, 5), dtype=np.float32)\n", + "# centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + " \n", + "# for i in range(positions):\n", + "# # Randomly select an electron hit\n", + "# # index = random.randint(0, len(self.images) - 1)\n", + "# index = 84\n", + "# hit = self.images[index]\n", + " \n", + "# # Random position for placing the electron hit\n", + "# x = random.randint(0, max_x - width)\n", + "# y = random.randint(0, max_y - height)\n", + "\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + "\n", + "# # Calculate the exact center based on pixel intensity\n", + "# total_intensity = np.sum(hit)\n", + "# if total_intensity > 0:\n", + "# y_coords, x_coords = np.indices(hit.shape)\n", + "# x_center = x + np.sum(x_coords * hit) / total_intensity\n", + "# y_center = y + np.sum(y_coords * hit) / total_intensity\n", + "# else:\n", + "# x_center = x + width / 2\n", + "# y_center = y + height / 2\n", + " \n", + "# canvas[y_min:y_max, x_min:x_max] = np.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255)\n", + "# bounding_boxes.append((x_center-1, y_center-1, x_center+1, y_center+1))\n", + "# bounding_boxes_training[i, 0] = 1\n", + "# bounding_boxes_training[i, 1:] = [x_center-1, y_center-1, x_center+1, y_center+1]\n", + "# centers.append((x_center, y_center))\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + "# index_.append(index)\n", + "\n", + "# # # Apply Gaussian noise\n", + "# # canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # # Apply scaled down dark noise\n", + "# # noise_int = np.random.randint(len(self.dark_noise))\n", + "# # canvas = canvas + self.dark_noise[noise_int] # Scaling down dark noise\n", + "\n", + "# # Clip values to valid range for display\n", + "# # canvas = np.clip(canvas, 0, 255).astype(np.uint8) \n", + " \n", + "# return (canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions)\n", + "\n", + "# def generate_multiple_images(self):\n", + "# \"\"\"Generates multiple images without specifying intensity range for the objects.\"\"\" \n", + "# results = []\n", + "# for i in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + "# positions = random.randint(13, self.max_electron_hits)\n", + "# results.append(self.place_image_on_canvas(positions))\n", + "# return results\n", + "\n", + "# def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + "# \"\"\"Saves object-containing images to an HDF5 file.\"\"\"\n", + "# total_images = len(data_with_objects) # Only count object-containing images now\n", + "# combined_data = []\n", + "\n", + "# # Add labels: 1 for images with objects\n", + "# for item in data_with_objects:\n", + "# combined_data.append((item[0], item[4], 1)) # 1 indicates it contains objects\n", + " \n", + "# # Save to HDF5 file\n", + "# with h5py.File(filename, 'w') as h5_file:\n", + "# theimages = h5_file.create_dataset('images', shape=(total_images, 64, 64), dtype='uint8')\n", + "# thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 13, 3), dtype='float32')\n", + "# labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# for i, (image, center, label) in enumerate(combined_data):\n", + "# theimages[i] = image\n", + "# thecenters[i] = center\n", + "# labels[i] = label\n", + "\n", + "\n", + "# # Example usage\n", + "# tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# # Creating an instance of ImageProcessor\n", + "# processor = ImageProcessor(30000, tiff_path, dark_noise_path, max_electron_hits=13)\n", + "\n", + "# # Generating images with objects\n", + "# data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# # Save only object-containing images to an HDF5 file\n", + "# processor.save_mixed_images_to_h5(data_with_intensity_range, [], '/home/da886/Final Electron counting project/Images and Labels/30KNoNoiseFixed-index84_13.h5')\n" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use this for sparse spots" + ] + }, + { + "cell_type": "code", + "execution_count": 294, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# # Adjust the center calculation to ensure the midpoint is correct\n", + "# class ImageProcessorAdjustedCorrectMidpoints:\n", + "# \"\"\"Image generation class with fixed spots and corrected midpoint calculation.\"\"\" \n", + " \n", + "# def __init__(self, num_to_generate, tiff_path, dark_noise_path, canvas_size=(64, 64), fixed_spots=10):\n", + "# \"\"\"Initializes the ImageProcessor class with a fixed number of electron spots.\"\"\"\n", + "# self.tiff_path = tiff_path\n", + "# self.dark_noise_path = dark_noise_path\n", + "# self.canvas_size = canvas_size\n", + "# self.num_to_generate = num_to_generate\n", + "# self.fixed_spots = fixed_spots\n", + " \n", + "# # Load only the relevant frames (e.g., index 84) from the TIFF file\n", + "# self.images = [self.load_image_from_tiff(tiff_path, 95)]\n", + "# self.dark_noise_images = [self.load_image_from_tiff(dark_noise_path, 0)]\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + " \n", + "# def load_image_from_tiff(self, tiff_path, frame_index):\n", + "# \"\"\"Loads a single image frame from a tiff file by index\"\"\"\n", + "# with Image.open(tiff_path) as img:\n", + "# img.seek(frame_index)\n", + "# return np.array(img)\n", + " \n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\"\"\"\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.0001\n", + "# sigma = var ** 0.5\n", + "# threshold = 8\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", + "\n", + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\"\"\"\n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\"\"\"\n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self):\n", + "# \"\"\"Places a fixed number of electron hits on the canvas with corrected midpoints.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "# height, width = self.images[0].shape\n", + "# max_x = self.canvas_size[1]\n", + "# max_y = self.canvas_size[0]\n", + "# centers = []\n", + " \n", + "# for i in range(self.fixed_spots):\n", + "# x = random.randint(1 - width//2, max_x - width//2 - 1)\n", + "# y = random.randint(1 - height//2, max_y - height//2 - 1)\n", + "# index = random.randint(0, len(self.images) - 1)\n", + "# hit = self.images[index]\n", + "\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + " \n", + "# x_center = x + width // 2 # Correct the center calculation to be the true midpoint\n", + "# y_center = y + height // 2 # Correct the center calculation to be the true midpoint\n", + " \n", + "# if y_min < 0:\n", + "# hit = hit[y_min*-1:, :]\n", + "# y_min = 0\n", + "\n", + "# if y_max > max_y:\n", + "# hit = hit[:-(y_max-max_y), :]\n", + "# y_max = max_y\n", + " \n", + "# if x_min < 0:\n", + "# hit = hit[:, x_min*-1:]\n", + "# x_min = 0\n", + " \n", + "# if x_max > max_x:\n", + "# hit = hit[:, :-(x_max-max_x)]\n", + "# x_max = max_x\n", + " \n", + "# # canvas[y_min:y_max, x_min:x_max] = np.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255)\n", + "# canvas[y_min:y_max, x_min:x_max] = hit\n", + "# centers.append((x_center, y_center))\n", + " \n", + "# canvas = self.noisy('gauss', canvas)\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas = canvas + self.dark_noise[noise_int]\n", + "# # canvas = np.clip(canvas, 0, 255).astype(np.uint8) \n", + "# return (canvas, centers)\n", + "\n", + "\n", + "# def generate_multiple_images(self):\n", + "# \"\"\"Generates multiple images with a fixed number of electron hits.\"\"\" \n", + "# results = []\n", + "# for i in range(self.num_to_generate):\n", + "# results.append(self.place_image_on_canvas())\n", + "# return results\n", + "\n", + "# tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# # Create an instance of the adjusted processor with exactly 10 electron spots and corrected midpoints\n", + "# processor_correct_midpoints = ImageProcessorAdjustedCorrectMidpoints(3, tiff_path, dark_noise_path, fixed_spots=10)\n", + "\n", + "# # Generate some images for analysis\n", + "# generated_images_correct_midpoints = processor_correct_midpoints.generate_multiple_images()\n", + "\n", + "# # Plot and visualize the generated images with centers marked\n", + "# fig, axes = plt.subplots(1, 3, figsize=(12, 4))\n", + "# for i, result in enumerate(generated_images_correct_midpoints):\n", + "# canvas, centers = result # Extract the canvas and centers from the result tuple\n", + "# axes[i].imshow(canvas, cmap='gray')\n", + "# for center in centers:\n", + "# axes[i].plot(center[0], center[1], 'ro',markersize=2) # Plot the centers as red dots\n", + "# axes[i].set_title(f'Image {i+1}')\n", + "# axes[i].axis('on')\n", + "\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 245, + "metadata": {}, + "outputs": [], "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import tifffile as tiff\n", - "import os\n", + "# # Adjust the code to generate only 3 images and ensure proper HDF5 saving\n", "\n", - "# Load the TIFF stack\n", - "file_path = '/home/m3-learning/Documents/myML/200kV_98000electron.tif'\n", - "tiff_stack = tiff.imread(file_path)\n", + "# import numpy as np\n", + "# import random\n", + "# from PIL import Image\n", + "# import matplotlib.pyplot as plt\n", + "# import h5py\n", "\n", - "# Check the shape of the stack to ensure it is a 3D array\n", - "print(tiff_stack.shape) # (num_slices, height, width)\n", + "# class ImageProcessorAdjustedCorrectMidpoints:\n", + "# \"\"\"Image generation class with fixed spots and corrected midpoint calculation.\"\"\" \n", + " \n", + "# def __init__(self, num_to_generate, tiff_path, dark_noise_path, canvas_size=(64, 64), fixed_spots=13):\n", + "# \"\"\"Initializes the ImageProcessor class with a fixed number of electron spots.\"\"\"\n", + "# self.tiff_path = tiff_path\n", + "# self.dark_noise_path = dark_noise_path\n", + "# self.canvas_size = canvas_size\n", + "# self.num_to_generate = num_to_generate\n", + "# self.fixed_spots = fixed_spots\n", + " \n", + "# # Load only the relevant frames (e.g., index 95) from the TIFF file\n", + "# self.images = [self.load_image_from_tiff(tiff_path, 95)]\n", + "# self.dark_noise_images = [self.load_image_from_tiff(dark_noise_path, 0)]\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + " \n", + "# def load_image_from_tiff(self, tiff_path, frame_index):\n", + "# \"\"\"Loads a single image frame from a tiff file by index\"\"\"\n", + "# with Image.open(tiff_path) as img:\n", + "# img.seek(frame_index)\n", + "# return np.array(img)\n", + " \n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\"\"\"\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.0001\n", + "# sigma = var ** 0.5\n", + "# threshold = 8\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", "\n", - "# Verify the shape\n", - "if len(tiff_stack.shape) != 3:\n", - " raise ValueError(\"The loaded TIFF stack is not a 3D array.\")\n", + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", "\n", - "# Function to plot multiple slices in a grid\n", - "def plot_slices(start, end):\n", - " fig, axes = plt.subplots(nrows=10, ncols=10, figsize=(15, 15))\n", - " fig.suptitle(f'Slices {start} to {end-1}')\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\"\"\"\n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\"\"\"\n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self):\n", + "# \"\"\"Places a fixed number of electron hits on the canvas with corrected midpoints.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "# height, width = self.images[0].shape\n", + "# max_x = self.canvas_size[1]\n", + "# max_y = self.canvas_size[0]\n", + "# centers_training = np.zeros((13, 3), dtype=np.float32)\n", + " \n", + "# for i in range(self.fixed_spots):\n", + "# x = random.randint(1 - width//2, max_x - width//2 - 1)\n", + "# y = random.randint(1 - height//2, max_y - height//2 - 1)\n", + "# hit = self.images[0]\n", + "\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + " \n", + "# x_center = x + width // 2 # Correct the center calculation to be the true midpoint\n", + "# y_center = y + height // 2 # Correct the center calculation to be the true midpoint\n", + " \n", + "# if y_min < 0:\n", + "# hit = hit[y_min*-1:, :]\n", + "# y_min = 0\n", + "\n", + "# if y_max > max_y:\n", + "# hit = hit[:-(y_max-max_y), :]\n", + "# y_max = max_y\n", + " \n", + "# if x_min < 0:\n", + "# hit = hit[:, x_min*-1:]\n", + "# x_min = 0\n", + " \n", + "# if x_max > max_x:\n", + "# hit = hit[:, :-(x_max-max_x)]\n", + "# x_max = max_x\n", + " \n", + "# canvas[y_min:y_max, x_min:x_max] = np.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255)\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + " \n", + "# # Apply noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + " \n", + "# centers.append((x_center, y_center))\n", + " \n", + " \n", + "# canvas = np.clip(canvas, 0, 255).astype(np.uint8) \n", + " \n", + "# return (canvas, centers_training)\n", + "\n", + "\n", + "# def generate_multiple_images(self):\n", + "# \"\"\"Generates multiple images with a fixed number of electron hits.\"\"\" \n", + "# results = []\n", + "# for i in range(self.num_to_generate):\n", + "# results.append(self.place_image_on_canvas())\n", + "# return results\n", + "\n", + "# def save_mixed_images_to_h5(self, data_with_objects, filename):\n", + "# \"\"\"Saves object-containing images to an HDF5 file.\n", + "\n", + "# Args:\n", + "# data_with_objects (list): List of data with objects to save.\n", + "# filename (str): Path to the HDF5 file.\n", + "# \"\"\"\n", + "# total_images = len(data_with_objects)\n", + "# combined_data = []\n", + "\n", + "# # Add labels: 1 for images with objects\n", + "# for item in data_with_objects:\n", + "# combined_data.append((item[0], item[1], 1)) # Use item[1] for centers\n", + " \n", + "# # Save to HDF5 file\n", + "# with h5py.File(filename, 'w') as h5_file:\n", + "# theimages = h5_file.create_dataset('images', shape=(total_images, 64, 64), dtype='uint8')\n", + "# thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 13, 3), dtype='float32')\n", + "# labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# for i, (image, center, label) in enumerate(combined_data):\n", + "# theimages[i] = image\n", + "# thecenters[i] = center\n", + "# labels[i] = label\n", + "\n", + "\n", + "# # Paths to the uploaded TIFF files (replace these with appropriate paths for testing)\n", + "\n", + "\n", + "# # Create an instance of the adjusted processor with 3 images and 13 fixed spots\n", + "\n", + "\n", + "# tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "\n", + "# # Create an instance of the adjusted processor with exactly 10 electron spots and corrected midpoints\n", + "# processor_correct_midpoints = ImageProcessorAdjustedCorrectMidpoints(30000, tiff_path, dark_noise_path, fixed_spots=13)\n", + "\n", + "\n", + "\n", + "# # Generating images with objects \n", + "# data_with_intensity_range = processor_correct_midpoints.generate_multiple_images()\n", + "\n", + "# # Save only object-containing images to an HDF5 file\n", + "# processor_correct_midpoints.save_mixed_images_to_h5(data_with_intensity_range, '/home/da886/Final Electron counting project/Images and Labels/30KFixed_13_Sparsespots.h5')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Good code" + ] + }, + { + "cell_type": "code", + "execution_count": 296, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# from PIL import Image\n", + "# import matplotlib.pyplot as plt\n", + "# import h5py\n", + "\n", + "# class ImageProcessorAdjustedCorrectMidpoints:\n", + "# \"\"\"Image generation class with fixed spots and corrected midpoint calculation.\"\"\" \n", " \n", - " for i, ax in enumerate(axes.flat):\n", - " slice_index = start + i\n", - " if slice_index < end:\n", - " ax.imshow(tiff_stack[slice_index], cmap='gray')\n", - " ax.set_title(f'Slice {slice_index}')\n", - " ax.axis('off')\n", - " else:\n", - " ax.axis('off')\n", + "# def __init__(self, num_to_generate, tiff_path, dark_noise_path, canvas_size=(64, 64), fixed_spots=13):\n", + "# \"\"\"Initializes the ImageProcessor class with a fixed number of electron spots.\"\"\"\n", + "# self.tiff_path = tiff_path\n", + "# self.dark_noise_path = dark_noise_path\n", + "# self.canvas_size = canvas_size\n", + "# self.num_to_generate = num_to_generate\n", + "# self.fixed_spots = fixed_spots\n", + " \n", + "# # Load all frames from the TIFF file\n", + "# self.images = self.load_all_frames_from_tiff(tiff_path)\n", + "# self.dark_noise_images = [self.load_image_from_tiff(dark_noise_path, 0)]\n", + " \n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", " \n", - " plt.tight_layout()\n", - " plt.subplots_adjust(top=0.95)\n", - " plt.show()\n", + "# def load_image_from_tiff(self, tiff_path, frame_index):\n", + "# \"\"\"Loads a single image frame from a tiff file by index\"\"\"\n", + "# with Image.open(tiff_path) as img:\n", + "# img.seek(frame_index)\n", + "# return np.array(img)\n", + " \n", + "# def load_all_frames_from_tiff(self, tiff_path):\n", + "# \"\"\"Loads all frames from a TIFF file into a list\"\"\"\n", + "# frames = []\n", + "# with Image.open(tiff_path) as img:\n", + "# for i in range(img.n_frames):\n", + "# img.seek(i)\n", + "# frames.append(np.array(img))\n", + "# return frames\n", + " \n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\"\"\"\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.0001\n", + "# sigma = var ** 0.5\n", + "# threshold = 8\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", "\n", - "# Plot the first 100 slices\n", - "plot_slices(0, 100)\n" + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\"\"\"\n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\"\"\"\n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self):\n", + "# \"\"\"Places a fixed number of electron hits on the canvas with corrected midpoints.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "# height, width = self.images[0].shape\n", + "# max_x = self.canvas_size[1]\n", + "# max_y = self.canvas_size[0]\n", + "# centers_training = np.zeros((13, 3), dtype=np.float32)\n", + " \n", + "# for i in range(self.fixed_spots):\n", + "# x = random.randint(1 - width//2, max_x - width//2 - 1)\n", + "# y = random.randint(1 - height//2, max_y - height//2 - 1)\n", + " \n", + "# # Randomly select a frame from the available frames in the TIFF file\n", + "# random_frame_index = random.randint(0, len(self.images) - 1)\n", + "# hit = self.images[random_frame_index]\n", + "\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + " \n", + "# x_center = x + width // 2 # Correct the center calculation to be the true midpoint\n", + "# y_center = y + height // 2 # Correct the center calculation to be the true midpoint\n", + " \n", + "# if y_min < 0:\n", + "# hit = hit[y_min*-1:, :]\n", + "# y_min = 0\n", + "\n", + "# if y_max > max_y:\n", + "# hit = hit[:-(y_max-max_y), :]\n", + "# y_max = max_y\n", + " \n", + "# if x_min < 0:\n", + "# hit = hit[:, x_min*-1:]\n", + "# x_min = 0\n", + " \n", + "# if x_max > max_x:\n", + "# hit = hit[:, :-(x_max-max_x)]\n", + "# x_max = max_x\n", + " \n", + "# canvas[y_min:y_max, x_min:x_max] = hit\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + " \n", + "# # Apply noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# # canvas = np.clip(canvas, 0, 255).astype(np.uint8) \n", + "# canvas = canvas + self.dark_noise[noise_int]\n", + " \n", + "# return (canvas, centers_training)\n", + "\n", + "\n", + "# def generate_multiple_images(self):\n", + "# \"\"\"Generates multiple images with a fixed number of electron hits.\"\"\" \n", + "# results = []\n", + "# for i in range(self.num_to_generate):\n", + "# results.append(self.place_image_on_canvas())\n", + "# return results\n", + "\n", + "# def save_mixed_images_to_h5(self, data_with_objects, filename):\n", + "# \"\"\"Saves object-containing images to an HDF5 file.\n", + "\n", + "# Args:\n", + "# data_with_objects (list): List of data with objects to save.\n", + "# filename (str): Path to the HDF5 file.\n", + "# \"\"\"\n", + "# total_images = len(data_with_objects)\n", + "# combined_data = []\n", + "\n", + "# # Add labels: 1 for images with objects\n", + "# for item in data_with_objects:\n", + "# combined_data.append((item[0], item[1], 1)) # Use item[1] for centers\n", + " \n", + "# # Save to HDF5 file\n", + "# with h5py.File(filename, 'w') as h5_file:\n", + "# theimages = h5_file.create_dataset('images', shape=(total_images, 64, 64), dtype='uint8')\n", + "# thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 13, 3), dtype='float32')\n", + "# labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# for i, (image, center, label) in enumerate(combined_data):\n", + "# theimages[i] = image\n", + "# thecenters[i] = center\n", + "# labels[i] = label\n", + "\n", + "\n", + "# # Paths to the uploaded TIFF files (replace these with appropriate paths for testing)\n", + "\n", + "\n", + "# # Create an instance of the adjusted processor with 3 images and 13 fixed spots\n", + "\n", + "\n", + "# tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "\n", + "# # Create an instance of the adjusted processor with exactly 10 electron spots and corrected midpoints\n", + "# processor_correct_midpoints = ImageProcessorAdjustedCorrectMidpoints(12000, tiff_path, dark_noise_path, fixed_spots=13)\n", + "\n", + "\n", + "\n", + "# # Generating images with objects \n", + "# data_with_intensity_range = processor_correct_midpoints.generate_multiple_images()\n", + "\n", + "# # Save only object-containing images to an HDF5 file\n", + "# processor_correct_midpoints.save_mixed_images_to_h5(data_with_intensity_range, '/home/da886/Final Electron counting project/Images and Labels/12KFixed_13_SparsespotsRandomIndex.h5')\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "With Random Noisy Images" + "### THIS IS MY MAIN CODE" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Generating images: 100%|██████████| 900000/900000 [05:31<00:00, 2715.46it/s]\n", - "Generating noise-only images: 100%|██████████| 100000/100000 [00:09<00:00, 10228.85it/s]\n" + "Generating images: 100%|██████████| 10/10 [00:00<00:00, 796.47it/s]\n", + "Generating noise-only images: 0it [00:00, ?it/s]\n" ] } ], @@ -128,8 +2046,8 @@ " num_to_generate,\n", " tiff_path, \n", " dark_noise_path, \n", - " canvas_size = (64, 64), \n", - " max_electron_hits = 13):\n", + " canvas_size = (256, 256), \n", + " max_electron_hits = 100):\n", " \"\"\"Initializes the ImageProcessor class\n", "\n", " Args:\n", @@ -137,7 +2055,7 @@ " tiff_path (str): Location of the tiff file that contains the electron hits\n", " dark_noise_path (str): Path to the noisy data\n", " canvas_size (tuple, optional): Size of the canvas to place the images on. Defaults to (64, 64).\n", - " max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 272.\n", + " max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 13.\n", " \"\"\" \n", " \n", " self.tiff_path = tiff_path\n", @@ -179,29 +2097,11 @@ " Returns:\n", " numpy array: Noisy image\n", " \"\"\"\n", - " \n", - " # if noise_typ == \"gauss\":\n", - " # row,col,= image.shape\n", - " # mean = 0 #taken from sparse frames of celeritas histogram . mean = -0.17 .RMSD = 1.319\n", - " # var = 0.0001 #square of the standard deviation from sparse frames histogram\n", - " # sigma = var**0.5\n", - " # threshold = 8 #8ADU\n", - " # gauss = np.random.normal(mean,sigma,(row,col)) #thresholding instead of adding noise\n", - " # tnoisy = image + gauss #just making sure they're not exactly the same\n", - "\n", - " # for x in range(row): #Noise thresholding so that only positive noise is added to the empty pixels\n", - " # for y in range(col):\n", - " # #each pixel should be an integer, not a floating point. Round each pixel after noise is added.\n", - " # if tnoisy[x][y] < threshold: #trying not to wipe out smaller contributions\n", - " # tnoisy[x][y] = 0\n", - "\n", - " # noisy = np.round(tnoisy) #+ gauss) #adding noise after thresholding to recreate the image\n", - " # return noisy\n", " if noise_typ == \"gauss\":\n", " row, col = image.shape\n", " mean = 0\n", " var = 0.0001\n", - " sigma = var**0.5\n", + " sigma = var ** 0.5\n", " threshold = 8\n", " gauss = np.random.normal(mean, sigma, (row, col))\n", " tnoisy = image + gauss\n", @@ -231,77 +2131,68 @@ " return dark_noise_stack_cropped\n", "\n", " \n", - " # def place_image_on_canvas(self, positions=3, intensity_range=(10, 255)):\n", - " def place_image_on_canvas(self, positions=3):\n", + " def place_image_on_canvas(self):\n", " \"\"\"Places the electron hits on the canvas without specifying intensity range.\"\"\"\n", " canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", " height, width = self.images[0].shape\n", " max_x = self.canvas_size[1]\n", " max_y = self.canvas_size[0]\n", - " bounding_boxes = []\n", " centers = []\n", - " index_ = []\n", - " bounding_boxes_training = np.zeros((self.max_electron_hits, 5), dtype=np.float32)\n", " centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", " \n", - " for i in range(positions):\n", + " for i in range(self.max_electron_hits):\n", + " x = random.randint(1 - width//2, max_x - width//2 - 1)\n", + " y = random.randint(1 - height//2, max_y - height//2 - 1)\n", + " \n", " # Randomly select an electron hit\n", - " index = random.randint(0, len(self.images) - 1)\n", + " # index = random.randint(0, 97999)\n", + " index = 95\n", " hit = self.images[index]\n", " \n", - " # Random position for placing the electron hit\n", - " x = random.randint(0, max_x - width)\n", - " y = random.randint(0, max_y - height)\n", - "\n", " y_min = y\n", " y_max = y + height\n", " x_min = x \n", " x_max = x + width\n", + " \n", + " x_center = x + width // 2 # Correct the center calculation to be the true midpoint\n", + " y_center = y + height // 2 # Correct the center calculation to be the true midpoint\n", + " \n", + " if y_min < 0:\n", + " hit = hit[y_min*-1:, :]\n", + " y_min = 0\n", "\n", - " # Calculate the exact center based on pixel intensity\n", - " total_intensity = np.sum(hit)\n", - " if total_intensity > 0:\n", - " y_coords, x_coords = np.indices(hit.shape)\n", - " x_center = x + np.sum(x_coords * hit) / total_intensity\n", - " y_center = y + np.sum(y_coords * hit) / total_intensity\n", - " else:\n", - " x_center = x + width / 2\n", - " y_center = y + height / 2\n", - " \n", - " canvas[y_min:y_max, x_min:x_max] = hit\n", - " bounding_boxes.append((x_center-1, y_center-1, x_center+1, y_center+1))\n", - " bounding_boxes_training[i, 0] = 1\n", - " bounding_boxes_training[i, 1:] = [x_center-1, y_center-1, x_center+1, y_center+1]\n", + " if y_max > max_y:\n", + " hit = hit[:-(y_max-max_y), :]\n", + " y_max = max_y\n", + " \n", + " if x_min < 0:\n", + " hit = hit[:, x_min*-1:]\n", + " x_min = 0\n", + " \n", + " if x_max > max_x:\n", + " hit = hit[:, :-(x_max-max_x)]\n", + " x_max = max_x\n", + " \n", + " # canvas[y_min:y_max, x_min:x_max] = hit\n", + " canvas[y_min:y_max, x_min:x_max]=np.clip(canvas[y_min:y_max, x_min:x_max] + hit, 0, 255)\n", " centers.append((x_center, y_center))\n", " centers_training[i, 0] = 1\n", " centers_training[i, 1:] = [x_center, y_center]\n", - " index_.append(index)\n", " \n", - " # Apply Gaussian noise\n", - " canvas = self.noisy('gauss', canvas)\n", - " noise_int = np.random.randint(len(self.dark_noise))\n", - " canvas = canvas + self.dark_noise[noise_int]\n", + " # # Apply Gaussian noise\n", + " # canvas = self.noisy('gauss', canvas)\n", + " # noise_int = np.random.randint(len(self.dark_noise))\n", + " # canvas = canvas + self.dark_noise[noise_int]\n", + " canvas = canvas \n", " \n", - " return (canvas, bounding_boxes, bounding_boxes_training, centers, centers_training, index_, positions, noise_int)\n", + " return (canvas, centers, centers_training)\n", "\n", - "\n", - " \n", - " #### USE THIS BLOCK TO GENERATE FIXED SET\n", - " # #def generate_multiple_images(self, intensity_range=(10, 255)):\n", - " # def generate_multiple_images(self, intensity_range=(200, 255)):\n", - " # \"\"\"Generates multiple images with specified intensity range for the objects.\"\"\" \n", - " # results = []\n", - " # for i in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", - " # results.append(self.place_image_on_canvas(positions=3, intensity_range=intensity_range))\n", - " # return results\n", " \n", - " #### USE THIS BLOCK TO GENERATE PADDED SET\n", " def generate_multiple_images(self):\n", " \"\"\"Generates multiple images without specifying intensity range for the objects.\"\"\" \n", " results = []\n", - " for i in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", - " positions = random.randint(13, self.max_electron_hits)\n", - " results.append(self.place_image_on_canvas(positions))\n", + " for _ in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + " results.append(self.place_image_on_canvas())\n", " return results\n", "\n", " \n", @@ -330,8 +2221,6 @@ "\n", " return noise_images\n", " \n", - " \n", - "\n", " def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", " \"\"\"Mixes object-containing images with noise-only images and saves to an HDF5 file\n", " \n", @@ -345,18 +2234,18 @@ "\n", " # Add labels: 1 for images with objects, 0 for noise-only images\n", " for item in data_with_objects:\n", - " combined_data.append((item[0], item[4], 1)) # 1 indicates it contains objects\n", + " combined_data.append((item[0], item[2], 1)) # 1 indicates it contains objects\n", " \n", " for noise_image in noise_images:\n", - " combined_data.append((noise_image, np.zeros((13, 3)), 0)) # 0 indicates noise-only\n", + " combined_data.append((noise_image, np.zeros((200, 3)), 0)) # 0 indicates noise-only\n", " \n", " # Shuffle the combined data\n", " random.shuffle(combined_data)\n", "\n", " # Save to HDF5 file\n", " with h5py.File(filename, 'w') as h5_file:\n", - " theimages = h5_file.create_dataset('images', shape=(total_images, 64, 64), dtype='uint8')\n", - " thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 13, 3), dtype='float32')\n", + " theimages = h5_file.create_dataset('images', shape=(total_images, 256, 256), dtype='uint8')\n", + " thecenters = h5_file.create_dataset('centers_training', shape=(total_images, 200, 3), dtype='float32')\n", " labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", " \n", " for i, (image, center, label) in enumerate(combined_data):\n", @@ -369,22 +2258,321 @@ "dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", "\n", "# Creating an instance of ImageProcessor\n", - "processor = ImageProcessor(900000, tiff_path, dark_noise_path, max_electron_hits=13)\n", + "processor = ImageProcessor(10, tiff_path, dark_noise_path, max_electron_hits=200)\n", "\n", "# Generating images with objects \n", "data_with_intensity_range = processor.generate_multiple_images()\n", "\n", "# Generating noise-only images\n", - "noise_only_images = processor.generate_noise_only_images(100000)\n", + "noise_only_images = processor.generate_noise_only_images(0)\n", "\n", "# Save mixed dataset to an HDF5 file\n", - "processor.save_mixed_images_to_h5(data_with_intensity_range, noise_only_images, '/home/da886/Final Electron counting project/Images and Labels/1milFixed_Mixed_13.h5')\n" + "processor.save_mixed_images_to_h5(data_with_intensity_range, noise_only_images, '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10KFixed_200_256by256_95indexNoNoiseChatGPT Analysis.h5')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "this is to test 1 spot" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating images: 100%|██████████| 15000/15000 [00:01<00:00, 14058.79it/s]\n", + "Generating noise-only images: 0it [00:00, ?it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import numpy as np\n", + "# import random\n", + "# from PIL import Image\n", + "# from tqdm import tqdm\n", + "# import h5py\n", + "\n", + "# class ImageProcessor:\n", + "# \"\"\"Image generation class\"\"\" \n", + "\n", + "# def __init__(self, \n", + "# num_to_generate,\n", + "# tiff_path, \n", + "# dark_noise_path, \n", + "# canvas_size=(32, 32), \n", + "# max_electron_hits=5): # Set max_electron_hits to 5\n", + "# \"\"\"Initializes the ImageProcessor class\n", + "\n", + "# Args:\n", + "# num_to_generate (int): Number of images to generate\n", + "# tiff_path (str): Location of the tiff file that contains the electron hits\n", + "# dark_noise_path (str): Path to the noisy data\n", + "# canvas_size (tuple, optional): Size of the canvas to place the images on. Defaults to (32, 32).\n", + "# max_electron_hits (int, optional): Maximum number of electron hits to place on the canvas. Defaults to 5.\n", + "# \"\"\" \n", + "\n", + "# self.tiff_path = tiff_path\n", + "# self.dark_noise_path = dark_noise_path\n", + "# self.canvas_size = canvas_size\n", + "# self.num_to_generate = num_to_generate\n", + "# self.max_electron_hits = max_electron_hits\n", + "\n", + "# # Loads the images from the tiff file\n", + "# self.images = self.load_images_from_tiff(tiff_path)\n", + "# self.dark_noise_images = self.load_images_from_tiff(dark_noise_path)\n", + "\n", + "# # Creates a dark stack of the same size as the canvas\n", + "# self.dark_noise = self.dark_stack(self.canvas_size[0])\n", + "\n", + "# def load_images_from_tiff(self, tiff_path):\n", + "# \"\"\"Loads the images from a tiff file\n", + "\n", + "# Args:\n", + "# tiff_path (str): Path to the tiff file\n", + "\n", + "# Returns:\n", + "# list: List of images\n", + "# \"\"\" \n", + "# with Image.open(tiff_path) as img:\n", + "# images = []\n", + "# for i in range(img.n_frames):\n", + "# img.seek(i)\n", + "# images.append(np.array(img))\n", + "# return images\n", + "\n", + "# def noisy(self, noise_typ, image): \n", + "# \"\"\"Adds noise to the images\n", + "\n", + "# Args:\n", + "# noise_typ (str): Type of noise to add\n", + "# image (numpy array): Image to add noise to\n", + "\n", + "# Returns:\n", + "# numpy array: Noisy image\n", + "# \"\"\"\n", + "# if noise_typ == \"gauss\":\n", + "# row, col = image.shape\n", + "# mean = 0\n", + "# var = 0.0001\n", + "# sigma = var ** 0.5\n", + "# threshold = 8\n", + "# gauss = np.random.normal(mean, sigma, (row, col))\n", + "# tnoisy = image + gauss\n", + "\n", + "# tnoisy[tnoisy < threshold] = 0\n", + "# noisy = np.round(tnoisy)\n", + "# return noisy\n", + "\n", + "# def deadcorr(self, image):\n", + "# \"\"\"Corrects the dead pixel within the dark reference frame by interpolating from near positions.\n", + "\n", + "# Args:\n", + "# image (numpy array): Image to correct\n", + "# \"\"\" \n", + "# temp = image.copy()\n", + "# temp[:, 248] = 0.5 * temp[:, 247] + 0.5 * temp[:, 246]\n", + "# return temp\n", + "\n", + "# def dark_stack(self, imgsize):\n", + "# \"\"\"Creates a dark stack of the same size as the canvas.\n", + "\n", + "# Args:\n", + "# imgsize (int): Size of the images in the stack\n", + "# \"\"\" \n", + "# dark_noise_stack_corrected = [self.deadcorr(image) for image in self.dark_noise_images]\n", + "# dark_noise_stack_cropped = [image[512:512+imgsize, 512:512+imgsize] for image in dark_noise_stack_corrected]\n", + "# return dark_noise_stack_cropped\n", + "\n", + "# def place_image_on_canvas(self):\n", + "# \"\"\"Places 5 electron hits: one at the center and one at each corner of the canvas.\"\"\"\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "# height, width = self.images[0].shape\n", + "# max_x, max_y = self.canvas_size[1], self.canvas_size[0]\n", + "# centers = []\n", + "# centers_training = np.zeros((self.max_electron_hits, 3), dtype=np.float32)\n", + "\n", + "# # Define positions: corners and center\n", + "# positions = {\n", + "# 0: (0, 0), # Top-left corner\n", + "# 1: (max_x - width, 0), # Top-right corner\n", + "# 2: (0, max_y - height), # Bottom-left corner\n", + "# 3: (max_x - width, max_y - height), # Bottom-right corner\n", + "# 4: ((max_x - width) // 2, (max_y - height) // 2) # Center\n", + "# }\n", + "\n", + "# for i in range(self.max_electron_hits):\n", + "# x, y = positions[i]\n", + "\n", + "# # Select an electron hit\n", + "# index = random.randint(0, len(self.images) - 1)\n", + "# hit = self.images[index]\n", + "\n", + "# # Define the placement boundaries\n", + "# y_min = y\n", + "# y_max = y + height\n", + "# x_min = x \n", + "# x_max = x + width\n", + "\n", + "# # Handle cases where the electron hit image goes beyond the canvas boundaries\n", + "# if y_min < 0:\n", + "# hit = hit[-y_min:, :]\n", + "# y_min = 0\n", + "\n", + "# if y_max > max_y:\n", + "# hit = hit[:-(y_max - max_y), :]\n", + "# y_max = max_y\n", + "\n", + "# if x_min < 0:\n", + "# hit = hit[:, -x_min:]\n", + "# x_min = 0\n", + "\n", + "# if x_max > max_x:\n", + "# hit = hit[:, :-(x_max - max_x)]\n", + "# x_max = max_x\n", + "\n", + "# # Place the electron hit on the canvas\n", + "# canvas[y_min:y_max, x_min:x_max] = np.clip(\n", + "# canvas[y_min:y_max, x_min:x_max] + hit, 0, 255\n", + "# )\n", + "\n", + "# # Calculate the center coordinates of the hit\n", + "# x_center = x_min + hit.shape[1] // 2\n", + "# y_center = y_min + hit.shape[0] // 2\n", + "\n", + "# # Update centers and centers_training\n", + "# centers.append((x_center, y_center))\n", + "# centers_training[i, 0] = 1\n", + "# centers_training[i, 1:] = [x_center, y_center]\n", + "\n", + "# # If you want to add noise, uncomment the following lines\n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # Add dark noise\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas += self.dark_noise[noise_int]\n", + "\n", + "# return (canvas, centers, centers_training)\n", + "\n", + "# def generate_multiple_images(self):\n", + "# \"\"\"Generates multiple images with 5 electron hits placed at specified positions.\"\"\" \n", + "# results = []\n", + "# for _ in tqdm(range(self.num_to_generate), desc=\"Generating images\"):\n", + "# results.append(self.place_image_on_canvas())\n", + "# return results\n", + "\n", + "# def generate_noise_only_images(self, num_images):\n", + "# \"\"\"Generates images containing only noise, with no electron hits.\n", + "\n", + "# Args:\n", + "# num_images (int): Number of noise-only images to generate.\n", + "\n", + "# Returns:\n", + "# list: List of generated noise-only images.\n", + "# \"\"\"\n", + "# noise_images = []\n", + "# for _ in tqdm(range(num_images), desc=\"Generating noise-only images\"):\n", + "# # Create an empty canvas\n", + "# canvas = np.zeros(self.canvas_size, dtype=np.uint8)\n", + "\n", + "# # Apply Gaussian noise\n", + "# canvas = self.noisy('gauss', canvas)\n", + "\n", + "# # Add dark noise\n", + "# noise_int = np.random.randint(len(self.dark_noise))\n", + "# canvas += self.dark_noise[noise_int]\n", + "\n", + "# noise_images.append(canvas)\n", + "\n", + "# return noise_images\n", + "\n", + "# def save_mixed_images_to_h5(self, data_with_objects, noise_images, filename):\n", + "# \"\"\"Mixes object-containing images with noise-only images and saves to an HDF5 file\n", + "\n", + "# Args:\n", + "# data_with_objects (list): List of data with objects to save.\n", + "# noise_images (list): List of noise-only images to save.\n", + "# filename (str): Path to the HDF5 file.\n", + "# \"\"\"\n", + "# total_images = len(data_with_objects) + len(noise_images)\n", + "# combined_data = []\n", + "\n", + "# # Add labels: 1 for images with objects, 0 for noise-only images\n", + "# for item in data_with_objects:\n", + "# combined_data.append((item[0], item[2], 1)) # 1 indicates it contains objects\n", + "\n", + "# for noise_image in noise_images:\n", + "# combined_data.append((noise_image, np.zeros((self.max_electron_hits, 3)), 0)) # 0 indicates noise-only\n", + "\n", + "# # Shuffle the combined data\n", + "# random.shuffle(combined_data)\n", + "\n", + "# # Save to HDF5 file\n", + "# with h5py.File(filename, 'w') as h5_file:\n", + "# theimages = h5_file.create_dataset('images', shape=(total_images, self.canvas_size[0], self.canvas_size[1]), dtype='uint8')\n", + "# thecenters = h5_file.create_dataset('centers_training', shape=(total_images, self.max_electron_hits, 3), dtype='float32')\n", + "# labels = h5_file.create_dataset('labels', shape=(total_images,), dtype='uint8')\n", + " \n", + "# for i, (image, center, label) in enumerate(combined_data):\n", + "# theimages[i] = image\n", + "# thecenters[i] = center\n", + "# labels[i] = label\n", + "\n", + "# # Paths to your TIFF files\n", + "# tiff_path = '/home/da886/ElectronCountingProject/200kV_98000electron.tif'\n", + "# dark_noise_path = '/home/da886/ElectronCountingProject/1000fps_fullRolling.tif'\n", + "\n", + "# # Creating an instance of ImageProcessor with max_electron_hits=5\n", + "# processor = ImageProcessor(\n", + "# num_to_generate=15000, \n", + "# tiff_path=tiff_path, \n", + "# dark_noise_path=dark_noise_path, \n", + "# max_electron_hits=5\n", + "# )\n", + "\n", + "# # Generating images with 5 electron hits placed at specified positions\n", + "# data_with_intensity_range = processor.generate_multiple_images()\n", + "\n", + "# # Generating noise-only images (if needed)\n", + "# noise_only_images = processor.generate_noise_only_images(0) # Change the number if you want noise-only images\n", + "\n", + "# # Save mixed dataset to an HDF5 file\n", + "# processor.save_mixed_images_to_h5(\n", + "# data_with_intensity_range, \n", + "# noise_only_images, \n", + "# '/home/da886/Final Electron counting project/Images and Labels/15KElectronHits_RandomindexCornersAndCenterWithNoise.h5'\n", + "# )\n", + "\n", + "# # Optional: Visual verification\n", + "# # Uncomment the following lines to display one of the generated images\n", + "# import matplotlib.pyplot as plt\n", + "# canvas, centers, centers_training = data_with_intensity_range[0]\n", + "# plt.imshow(canvas, cmap='gray')\n", + "# for center in centers:\n", + "# plt.scatter(center[0], center[1], c='red', marker='x') # Mark the centers\n", + "# plt.show()\n" ] } ], "metadata": { "kernelspec": { - "display_name": "objectdetection", + "display_name": "sod", "language": "python", "name": "python3" }, @@ -398,7 +2586,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.12.4" } }, "nbformat": 4, diff --git a/Final Electron counting project/Model Training(Fixed)Experimental 13.ipynb b/Final Electron counting project/Model Training(Fixed)Experimental 13.ipynb index f41d8fd..022782b 100644 --- a/Final Electron counting project/Model Training(Fixed)Experimental 13.ipynb +++ b/Final Electron counting project/Model Training(Fixed)Experimental 13.ipynb @@ -20,8 +20,8 @@ "# # Restrict TensorFlow to only use the second GPU\n", "# gpus = tf.config.experimental.list_physical_devices('GPU')\n", "# if gpus:\n", - "# tf.config.experimental.set_visible_devices(gpus[9], 'GPU')\n", - "# device = '/gpu:9'\n", + "# tf.config.experimental.set_visible_devices(gpus[0], 'GPU')\n", + "# device = '/gpu:0'\n", "# except RuntimeError as e:\n", "# print(e)\n", "\n", @@ -37,38 +37,40 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-09-19 22:01:30.754276: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2024-09-19 22:01:30.770420: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2024-09-19 22:01:30.784279: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2024-09-19 22:01:30.788452: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "2024-09-19 22:01:30.801692: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "2024-09-26 16:47:42.456463: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2024-09-26 16:47:42.469230: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2024-09-26 16:47:42.481709: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2024-09-26 16:47:42.485437: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2024-09-26 16:47:42.496369: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2024-09-19 22:01:31.395803: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + "2024-09-26 16:47:43.119582: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:4', '/job:localhost/replica:0/task:0/device:GPU:5')\n" + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2024-09-19 22:01:32.602103: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:4f:00.0, compute capability: 8.0\n", - "2024-09-19 22:01:32.603579: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79196 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:c5:00.0, compute capability: 8.0\n" + "2024-09-26 16:47:44.687686: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79194 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", + "2024-09-26 16:47:44.689204: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79194 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", + "2024-09-26 16:47:44.691175: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79194 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" ] } ], "source": [ "\n", "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"4,5\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", "\n", "import tensorflow as tf\n", - "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:4\", \"/gpu:5\"])" + "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\", \"/gpu:1\",\"/gpu:2\"])\n", + "# strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\"])" ] }, { @@ -245,69 +247,69 @@ "metadata": {}, "outputs": [], "source": [ - "# class ModelBuilder:\n", - "# def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=1e-3, weights_path=None):\n", - "# self.input_shape = input_shape\n", - "# self.num_classes = num_classes\n", - "# self.num_coordinates = num_coordinates\n", - "# self.learning_rate = learning_rate\n", - "# self.model = self.build_model()\n", + "class ModelBuilder:\n", + " def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=1e-3, weights_path=None):\n", + " self.input_shape = input_shape\n", + " self.num_classes = num_classes\n", + " self.num_coordinates = num_coordinates\n", + " self.learning_rate = learning_rate\n", + " self.model = self.build_model()\n", "\n", - "# # Load weights if a path is provided\n", - "# if weights_path is not None:\n", - "# self.model.load_weights(weights_path)\n", + " # Load weights if a path is provided\n", + " if weights_path is not None:\n", + " self.model.load_weights(weights_path)\n", "\n", - "# self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", - "# # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", + " self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", + " # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", "\n", - "# def build_model(self):\n", - "# x_input = layers.Input(shape=self.input_shape)\n", - "# x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x_input)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.BatchNormalization()(x)\n", - "# x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x)\n", + " def build_model(self):\n", + " x_input = layers.Input(shape=self.input_shape)\n", + " x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x_input)\n", + " x = layers.MaxPool2D()(x)\n", + " x = layers.BatchNormalization()(x)\n", + " x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x)\n", " \n", - "# x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.Dropout(0.05)(x)\n", - "# x = layers.BatchNormalization()(x)\n", + " x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", + " x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", + " x = layers.Dropout(0.1)(x)\n", + " x = layers.BatchNormalization()(x)\n", " \n", " \n", - "# x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.Dropout(0.05)(x)\n", - "# x = layers.BatchNormalization()(x)\n", + " x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", + " x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", + " x = layers.Dropout(0.2)(x)\n", + " x = layers.BatchNormalization()(x)\n", " \n", " \n", - "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.Dropout(0.1)(x)\n", - "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.Dropout(0.1)(x)\n", + " x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + " # x = layers.MaxPool2D()(x)\n", + " x = layers.Dropout(0.2)(x)\n", + " x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + " # x = layers.MaxPool2D()(x)\n", + " x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", + " x = layers.MaxPool2D()(x)\n", + " x = layers.Dropout(0.2)(x)\n", " \n", - "# x = layers.Conv2D(256, kernel_size=5, padding='same', activation='relu')(x)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.BatchNormalization()(x)\n", - "# # x = layers.Dropout(0.1)(x)\n", + " x = layers.Conv2D(256, kernel_size=5, padding='same', activation='relu')(x)\n", + " x = layers.MaxPool2D()(x)\n", + " x = layers.BatchNormalization()(x)\n", + " x = layers.Dropout(0.2)(x)\n", " \n", - "# x = layers.Flatten()(x)\n", + " x = layers.GlobalAveragePooling2D()(x)\n", " \n", " \n", " \n", - "# x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", - "# x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", + " x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", + " x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", " \n", - "# return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", + " return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", "\n", - "# def compile_model(self, loss_function):\n", - "# self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", + " def compile_model(self, loss_function):\n", + " self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", "\n", - "# def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", - "# history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", - "# return history\n" + " def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", + " history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", + " return history\n" ] }, { @@ -323,53 +325,67 @@ "metadata": {}, "outputs": [], "source": [ - "class ModelBuilder:\n", - " def __init__(self, input_shape=(64, 64, 1), num_classes=13, num_coordinates=2, learning_rate=1e-2, weights_path=None):\n", - " self.input_shape = input_shape\n", - " self.num_classes = num_classes\n", - " self.num_coordinates = num_coordinates\n", - " self.learning_rate = learning_rate\n", - " self.model = self.build_model()\n", + "# class ModelBuilder:\n", + "# def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=1e-3, weights_path=None):\n", + "# self.input_shape = input_shape\n", + "# self.num_classes = num_classes\n", + "# self.num_coordinates = num_coordinates\n", + "# self.learning_rate = learning_rate\n", + "# self.model = self.build_model()\n", "\n", - " # Load weights if a path is provided\n", - " if weights_path is not None:\n", - " self.model.load_weights(weights_path)\n", + "# # Load weights if a path is provided\n", + "# if weights_path is not None:\n", + "# self.model.load_weights(weights_path)\n", "\n", - " self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", - " # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", + "# self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", + "# # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", "\n", - " def build_model(self):\n", - " x_input = layers.Input(shape=self.input_shape)\n", + "# def build_model(self):\n", + "# # x_input = layers.Input(shape=self.input_shape)\n", " \n", - " x_1 = layers.Conv2D(32, kernel_size=6, padding='same', activation='relu')(x_input)\n", - " x_2 = layers.Conv2D(32, kernel_size=8, padding='same', activation='relu')(x_input)\n", - " x_3 = layers.Conv2D(64, kernel_size=19, padding='same', activation='relu')(x_input)\n", + "# # x_1 = layers.Conv2D(64, kernel_size=6,strides =3, padding='same', activation='relu')(x_input)\n", + "# # x_2 = layers.Conv2D(128, kernel_size=8,strides =3, padding='same', activation='relu')(x_input)\n", + "# # x_3 = layers.Conv2D(256, kernel_size=19,strides =3, padding='same', activation='relu')(x_input)\n", " \n", - " x = layers.concatenate([x_1, x_2, x_3])\n", - " x = layers.Flatten()(x)\n", + "# # x = layers.concatenate([x_1, x_2, x_3])\n", + "# # x = layers.Flatten()(x)\n", " \n", - " x = layers.Dense(64, activation='relu')(x)\n", - " # x = layers.Dropout(0.1)(x)\n", - " x = layers.Dense(32, activation='relu')(x)\n", - " # x = layers.Dropout(0.1)(x)\n", - " x = layers.Dense(16, activation='relu')(x)\n", + "# # x = layers.Dense(128, activation='relu')(x)\n", + "# # # x = layers.Dropout(0.1)(x)\n", + "# # x = layers.Dense(64, activation='relu')(x)\n", + "# # # x = layers.Dropout(0.1)(x)\n", + "# # x = layers.Dense(64, activation='relu')(x)\n", " \n", - " x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", - " x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", " \n", - " return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", + "# x_input = layers.Input(shape=self.input_shape)\n", + " \n", + "# x_1 = layers.Conv2D(128, kernel_size=6,strides =3, padding='same', activation='relu')(x_input)\n", + "# x_2 = layers.Conv2D(128, kernel_size=8,strides =3, padding='same', activation='relu')(x_input)\n", + "# x_3 = layers.Conv2D(128, kernel_size=19,strides =3, padding='same', activation='relu')(x_input)\n", + " \n", + "# x = layers.concatenate([x_1, x_2, x_3])\n", + "# x = layers.GlobalAveragePooling2D()(x)\n", + " \n", + "# x = layers.Dense(256, activation='relu')(x)\n", + "# x = layers.Dense(128, activation='relu')(x)\n", + "# x = layers.Dense(64, activation='relu')(x)\n", + " \n", + "# x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", + "# x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", + " \n", + "# return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", "\n", - " def compile_model(self, loss_function):\n", - " self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", + "# def compile_model(self, loss_function):\n", + "# self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", "\n", - " def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", - " history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", - " return history\n" + "# def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", + "# history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", + "# return history\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -379,7 +395,7 @@ "# -----------------------------\n", "\n", "# Load data\n", - "h5_filename = '/home/da886/Final Electron counting project/Images and Labels/1milFixed_Mixed_13.h5' \n", + "h5_filename = '/home/da886/Final Electron counting project/Images and Labels/30KFixed_5.h5' \n", "\n", "data_loader = DataLoader(h5_filename)\n", "images, centers = data_loader.load_data()\n" @@ -387,12 +403,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -403,16 +419,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -429,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -443,7 +459,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -457,9 +473,9 @@ ], "source": [ "\n", - "batch_size = 2500\n", - "train_dataset = train_dataset.shuffle(buffer_size=10000, reshuffle_each_iteration=True).batch(batch_size)\n", - "val_dataset = val_dataset.shuffle(buffer_size=10000).batch(batch_size)\n", + "batch_size = 500\n", + "train_dataset = train_dataset.shuffle(buffer_size=8000, reshuffle_each_iteration=True).batch(batch_size)\n", + "val_dataset = val_dataset.shuffle(buffer_size=8000).batch(batch_size)\n", "\n", "# Check the shape of the datasets\n", "print(f'Train Images: {train_images.shape}, Train Midpoints: {train_midpoints.shape}')\n", @@ -468,12 +484,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -488,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -496,13620 +512,4117 @@ "\n", "# Set up learning rate scheduler\n", "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(\n", - " monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=7e-8\n", + " monitor='val_loss', factor=0.8, patience=10, verbose=1, mode='min', min_lr=7e-8\n", ")\n" ] }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# import tensorflow as tf\n", - "##### used this initially \n", - "# class DynamicHuberLoss(tf.keras.losses.Loss):\n", - "# def __init__(self, initial_delta, final_delta, total_epochs, **kwargs):\n", - "# super().__init__(**kwargs)\n", - "# self.initial_delta = initial_delta\n", - "# self.final_delta = final_delta\n", - "# self.total_epochs = total_epochs\n", - "# self.current_epoch = 0\n", - "\n", - "# def call(self, y_true, y_pred):\n", - "# # Compute current delta\n", - "# delta = self.initial_delta - ((self.initial_delta - self.final_delta) * (self.current_epoch / self.total_epochs))\n", - "# # Compute Huber loss with current delta\n", - "# return tf.keras.losses.huber(y_true, y_pred, delta=delta)\n", - "\n", - "# def update_epoch(self, epoch):\n", - "# self.current_epoch = epoch\n", - "\n", - "class DynamicHuberLoss(tf.keras.losses.Loss):\n", - " def __init__(self, initial_delta=1.0, final_delta=0.1, total_epochs=1000, **kwargs):\n", - " super().__init__(**kwargs)\n", - " self.initial_delta = initial_delta\n", - " self.final_delta = final_delta\n", - " self.total_epochs = total_epochs\n", - " self.current_epoch = 0\n", - "\n", - " def call(self, y_true, y_pred):\n", - " # Dynamically adjust delta based on the current epoch\n", - " delta = self.initial_delta - ((self.initial_delta - self.final_delta) * (self.current_epoch / self.total_epochs))\n", - " error = y_true - y_pred\n", - " abs_error = tf.abs(error)\n", - " quadratic = tf.minimum(abs_error, delta)\n", - " linear = abs_error - quadratic\n", - " loss = 0.5 * quadratic**2 + delta * linear\n", - " return tf.reduce_mean(loss)\n", - "\n", - " def update_epoch(self, epoch):\n", - " self.current_epoch = epoch" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# Instantiate the dynamic Huber loss\n", - "dynamic_huber_loss = DynamicHuberLoss(initial_delta=1.0, final_delta=0.1, total_epochs=1000)\n", - "\n", - "\n", - "\n", - "# Create a custom callback to update the epoch\n", - "class UpdateEpochCallback(tf.keras.callbacks.Callback):\n", - " def __init__(self, loss_fn):\n", - " super().__init__()\n", - " self.loss_fn = loss_fn\n", - " self.current_epoch = 0\n", - "\n", - " def on_epoch_begin(self, epoch, logs=None):\n", - " self.loss_fn.update_epoch(epoch)\n", - "\n", - "# Instantiate the callback\n", - "update_epoch_callback = UpdateEpochCallback(dynamic_huber_loss)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
Model: \"functional\"\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1mModel: \"functional\"\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃ Layer (type)        ┃ Output Shape      ┃    Param # ┃ Connected to      ┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n",
-       "│ input_layer         │ (None, 64, 64, 1) │          0 │ -                 │\n",
-       "│ (InputLayer)        │                   │            │                   │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ conv2d (Conv2D)     │ (None, 64, 64,    │      1,184 │ input_layer[0][0] │\n",
-       "│                     │ 32)               │            │                   │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ conv2d_1 (Conv2D)   │ (None, 64, 64,    │      2,080 │ input_layer[0][0] │\n",
-       "│                     │ 32)               │            │                   │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ conv2d_2 (Conv2D)   │ (None, 64, 64,    │     23,168 │ input_layer[0][0] │\n",
-       "│                     │ 64)               │            │                   │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ concatenate         │ (None, 64, 64,    │          0 │ conv2d[0][0],     │\n",
-       "│ (Concatenate)       │ 128)              │            │ conv2d_1[0][0],   │\n",
-       "│                     │                   │            │ conv2d_2[0][0]    │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ flatten (Flatten)   │ (None, 524288)    │          0 │ concatenate[0][0] │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ dense (Dense)       │ (None, 64)        │ 33,554,496 │ flatten[0][0]     │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ dense_1 (Dense)     │ (None, 32)        │      2,080 │ dense[0][0]       │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ dense_2 (Dense)     │ (None, 16)        │        528 │ dense_1[0][0]     │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ x_midpoints (Dense) │ (None, 26)        │        442 │ dense_2[0][0]     │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ x_midpoints_reshape │ (None, 1, 13, 2)  │          0 │ x_midpoints[0][0] │\n",
-       "│ (Reshape)           │                   │            │                   │\n",
-       "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n",
-       "
\n" - ], - "text/plain": [ - "┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n", - "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n", - "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n", - "│ input_layer │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", - "│ (\u001b[38;5;33mInputLayer\u001b[0m) │ │ │ │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, │ \u001b[38;5;34m1,184\u001b[0m │ input_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "│ │ \u001b[38;5;34m32\u001b[0m) │ │ │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, │ \u001b[38;5;34m2,080\u001b[0m │ input_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "│ │ \u001b[38;5;34m32\u001b[0m) │ │ │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, │ \u001b[38;5;34m23,168\u001b[0m │ input_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "│ │ \u001b[38;5;34m64\u001b[0m) │ │ │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ concatenate │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, │ \u001b[38;5;34m0\u001b[0m │ conv2d[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ (\u001b[38;5;33mConcatenate\u001b[0m) │ \u001b[38;5;34m128\u001b[0m) │ │ conv2d_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ │ │ │ conv2d_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m524288\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ concatenate[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m33,554,496\u001b[0m │ flatten[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m2,080\u001b[0m │ dense[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m528\u001b[0m │ dense_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ x_midpoints (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m26\u001b[0m) │ \u001b[38;5;34m442\u001b[0m │ dense_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ x_midpoints_reshape │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ x_midpoints[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │ │\n", - "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
 Total params: 33,583,978 (128.11 MB)\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m33,583,978\u001b[0m (128.11 MB)\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
 Trainable params: 33,583,978 (128.11 MB)\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m33,583,978\u001b[0m (128.11 MB)\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
 Non-trainable params: 0 (0.00 B)\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Initialize the ModelBuilder within the strategy scope\n", - "with strategy.scope():\n", - " # Instantiate the model builder\n", - " model_builder = ModelBuilder()\n", - "\n", - " # Build the model\n", - " model_builder.build_model()\n", - "\n", - " # Display the model architecture\n", - " model_builder.model.summary()\n", - "\n", - " # Compile the model\n", - " model_builder.compile_model(loss_function=dynamic_huber_loss)\n", - " # model_builder.compile_model(loss_function=tf.keras.losses.MeanSquaredError())\n", - " # If using a custom loss function, replace the above line with:\n", - " # model_builder.compile_model(loss_function=custom_loss(exponent=2))\n" - ] - }, { "cell_type": "code", "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:04:22.663285: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", - "2024-09-19 22:04:25.837729: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", - "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "W0000 00:00:1726783465.886435 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.909525 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.930864 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.939354 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.944529 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.966031 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.973419 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.976060 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.981151 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.984779 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783465.992018 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.018980 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.027923 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.048390 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.050691 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.053544 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.057428 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.059687 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.062697 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.076687 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.079516 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.087088 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.098010 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.109441 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.123060 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.139511 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.181501 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.194373 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.203451 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.217789 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.238739 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.269299 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.288503 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.341878 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.392738 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.461805 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.477208 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783466.694154 854951 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.182110 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.197140 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.200889 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.218369 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.223151 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.242547 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.247090 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.267827 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.275108 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.297142 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.302225 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.324698 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.329517 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.349493 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.354357 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.385473 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.392650 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.413403 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.415459 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.441565 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.446806 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.478334 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.513618 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.538726 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.544188 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.830933 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.849820 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.896271 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.907892 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.912627 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.916311 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.920834 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.925524 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.932757 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.936978 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.942039 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.946514 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.951269 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.956209 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.961148 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.965794 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.972906 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.977578 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.979656 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.985944 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.991230 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783468.993289 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.024608 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.029763 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.035266 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.066963 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.083744 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.089274 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.116316 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.132965 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.177410 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.203171 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.209213 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.213378 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.217806 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.222707 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.227292 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.231891 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m 1/320\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m37:31\u001b[0m 7s/step - loss: 0.0329" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "W0000 00:00:1726783469.238135 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.240100 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.245187 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.269757 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.275125 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783469.291616 854942 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 176ms/step - loss: 0.0205" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:05:25.341287: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "2024-09-19 22:05:25.341398: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "2024-09-19 22:05:27.718102: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n", - "W0000 00:00:1726783528.004793 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.010288 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.012280 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.013958 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.015740 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.020114 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.024787 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.028970 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.034458 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.039113 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.043482 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.048718 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.054079 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.059039 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.064001 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.070761 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.077421 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.083998 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.090772 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.097838 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.104777 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.113431 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.122040 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.129058 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.137446 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.144288 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.151046 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.158947 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.166670 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.181653 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.196545 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.212130 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.227035 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.237444 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.247438 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.248701 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.249976 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.252065 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.253831 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.257408 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.260930 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.270255 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.279787 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.305430 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.336073 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.342231 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.344435 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.346630 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.351419 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.353983 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.360239 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.365002 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.371444 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.377890 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.384641 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.390939 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.405804 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.412713 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.427673 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.442656 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.453142 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.468210 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.478791 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.487337 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.498916 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.509275 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.520103 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.532126 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.546183 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.556849 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.567921 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.581784 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.592513 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.603359 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.614770 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.625654 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.639113 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.650537 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.652203 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.665676 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.667720 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.669234 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.688191 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.690482 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.694198 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.709815 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.724193 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.728170 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.769345 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.785301 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.835329 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.861087 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.882064 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.902830 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.919759 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.941134 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.974718 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783528.991570 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.023450 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.056207 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.085494 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.117234 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.154273 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.183574 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.238139 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.275903 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.327823 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.382187 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.441829 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.493261 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.541403 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.601650 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.691279 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.741254 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.864603 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.954648 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783529.962297 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.082050 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.095004 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.102692 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.152133 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.165131 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.186232 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.236882 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.308561 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.329822 854953 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.547976 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726783530.630244 854945 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m73s\u001b[0m 206ms/step - loss: 0.0205 - val_loss: 0.0101 - learning_rate: 0.0100\n", - "Epoch 2/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:05:35.053654: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - loss: 0.0165" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:06:43.434191: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m73s\u001b[0m 200ms/step - loss: 0.0165 - val_loss: 0.0098 - learning_rate: 0.0100\n", - "Epoch 3/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:06:47.781143: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0164" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:07:53.756896: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 200ms/step - loss: 0.0164 - val_loss: 0.0102 - learning_rate: 0.0100\n", - "Epoch 4/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - loss: 0.0164" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:09:04.457036: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 201ms/step - loss: 0.0164 - val_loss: 0.0098 - learning_rate: 0.0100\n", - "Epoch 5/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:09:08.829815: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0163" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:10:14.798673: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 200ms/step - loss: 0.0163 - val_loss: 0.0097 - learning_rate: 0.0100\n", - "Epoch 6/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0163" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:11:25.151608: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 200ms/step - loss: 0.0163 - val_loss: 0.0097 - learning_rate: 0.0100\n", - "Epoch 7/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - loss: 0.0163" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:12:35.885096: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 201ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 8/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:13:46.543671: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 201ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 9/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:13:50.944685: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:14:57.109400: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 200ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 10/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:16:07.856587: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 201ms/step - loss: 0.0162 - val_loss: 0.0104 - learning_rate: 0.0100\n", - "Epoch 11/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0164" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:17:18.515569: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 200ms/step - loss: 0.0164 - val_loss: 0.0097 - learning_rate: 0.0100\n", - "Epoch 12/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0163" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:18:29.132195: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 200ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 13/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0163" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:19:39.226824: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0163 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 14/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:20:51.334337: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m72s\u001b[0m 199ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 15/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:22:01.822990: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 200ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 16/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:23:11.963341: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 17/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:23:16.355827: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:24:22.191687: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 18/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:25:32.315119: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 19/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:26:42.631636: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 19: ReduceLROnPlateau reducing learning rate to 0.008999999798834325.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0100\n", - "Epoch 20/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:27:52.596010: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 21/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:29:02.346358: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 22/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0163" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:30:12.401589: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0162 - val_loss: 0.0097 - learning_rate: 0.0090\n", - "Epoch 23/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:31:22.364045: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 24/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:32:32.511151: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 25/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:33:42.349529: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 194ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 26/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:34:52.403022: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 27/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:36:02.619607: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 28/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:37:12.703070: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0162 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 29/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:38:22.714790: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 29: ReduceLROnPlateau reducing learning rate to 0.008099999651312828.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0090\n", - "Epoch 30/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:39:34.459771: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m72s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0081\n", - "Epoch 31/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:40:44.429453: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0081\n", - "Epoch 32/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:41:54.560449: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0081\n", - "Epoch 33/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0162" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:43:02.470386: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "2024-09-19 22:43:04.800364: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0096 - learning_rate: 0.0081\n", - "Epoch 34/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:44:14.935711: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0081\n", - "Epoch 35/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:45:24.959942: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0081\n", - "Epoch 36/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:46:34.846024: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0081\n", - "Epoch 37/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:47:44.880717: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0081\n", - "Epoch 38/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:48:54.886356: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0098 - learning_rate: 0.0081\n", - "Epoch 39/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:50:05.073107: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 39: ReduceLROnPlateau reducing learning rate to 0.007289999350905419.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0081\n", - "Epoch 40/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:51:15.024198: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 41/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:52:25.110805: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 42/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:53:35.009331: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 43/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:54:44.970678: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 44/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:55:54.941424: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 45/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:57:04.735364: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 46/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:58:14.661641: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 47/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:59:24.630230: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0098 - learning_rate: 0.0073\n", - "Epoch 48/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:00:34.637166: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 49/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:01:43.950610: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 49: ReduceLROnPlateau reducing learning rate to 0.006560999248176813.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0097 - learning_rate: 0.0073\n", - "Epoch 50/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:02:52.973023: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 195ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 51/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:03:59.593842: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 52/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:05:05.719582: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 53/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:06:14.061577: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 54/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:07:18.259570: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 55/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:08:28.606156: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 56/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:09:38.786430: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 57/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:10:48.600305: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 58/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:11:58.528604: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 59/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:13:08.649530: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 59: ReduceLROnPlateau reducing learning rate to 0.005904899490997195.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0097 - learning_rate: 0.0066\n", - "Epoch 60/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:14:18.779513: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 61/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:15:29.064883: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 62/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:16:37.141312: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 63/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:17:41.334691: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 64/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:18:51.138631: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 65/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:20:01.083299: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0161 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 66/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:20:05.484798: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:21:11.341371: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 67/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:22:21.441023: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 68/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:23:31.471635: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 69/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:24:39.527830: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 69: ReduceLROnPlateau reducing learning rate to 0.00531440949998796.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0059\n", - "Epoch 70/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:25:43.725968: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 71/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:26:53.601549: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 72/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:28:03.193484: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 73/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:29:13.234133: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 74/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:30:23.346745: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 75/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:31:33.409286: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 76/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0161" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:32:41.596947: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 77/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:33:45.710428: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 78/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:34:55.633417: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 79/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:36:05.885642: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 79: ReduceLROnPlateau reducing learning rate to 0.004782968759536744.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0053\n", - "Epoch 80/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:37:17.730049: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m72s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 81/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:38:25.346646: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 196ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 82/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:39:34.179690: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 83/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:40:40.116273: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 84/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:41:48.254541: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 85/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:42:58.487251: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 86/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:44:06.506354: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 87/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:45:10.437796: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 88/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:46:20.594858: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 89/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:47:30.719618: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 89: ReduceLROnPlateau reducing learning rate to 0.0043046717997640375.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0048\n", - "Epoch 90/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:48:41.036269: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 91/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:49:50.960832: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 92/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:50:59.255736: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 93/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:52:09.309194: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 94/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:53:16.332898: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 95/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:54:26.399479: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 96/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:55:30.351237: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 97/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:56:38.547723: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 98/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:57:42.737043: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 99/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:58:52.889380: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 99: ReduceLROnPlateau reducing learning rate to 0.0038742044940590858.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0043\n", - "Epoch 100/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:59:57.491512: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 101/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:01:09.408230: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m72s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 102/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:02:17.697306: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 103/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:03:21.719486: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 104/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:04:29.686955: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 105/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:05:33.894213: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 106/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:06:43.679515: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0039\n", - "Epoch 107/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:07:51.827923: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 108/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:08:55.862970: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 109/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:10:03.868567: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 109: ReduceLROnPlateau reducing learning rate to 0.003486784128472209.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0098 - learning_rate: 0.0039\n", - "Epoch 110/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:11:09.735253: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0035\n", - "Epoch 111/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:12:18.253686: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0098 - learning_rate: 0.0035\n", - "Epoch 112/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:13:28.369946: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0035\n", - "Epoch 113/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:14:36.520833: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0035\n", - "Epoch 114/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:15:40.589686: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0035\n", - "Epoch 115/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:16:51.257965: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 201ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0035\n", - "Epoch 116/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:17:59.456572: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0035\n", - "Epoch 117/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:19:03.451234: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0035\n", - "Epoch 118/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:20:13.865396: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 200ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0035\n", - "Epoch 119/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:21:23.881666: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 119: ReduceLROnPlateau reducing learning rate to 0.003138105757534504.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0035\n", - "Epoch 120/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:22:31.836425: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 121/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:23:35.665168: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 122/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:24:45.741685: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 123/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:25:53.833645: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 124/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:26:57.827046: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 125/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:28:08.061648: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 126/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:29:18.173051: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 127/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:30:26.198495: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 128/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:31:30.803968: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 201ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 129/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:32:44.668480: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 129: ReduceLROnPlateau reducing learning rate to 0.0028242952656000854.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m74s\u001b[0m 210ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0031\n", - "Epoch 130/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:32:49.052728: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:33:52.754785: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 131/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:35:09.480182: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m77s\u001b[0m 211ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 132/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:36:17.351630: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 133/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:37:21.806740: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 200ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 134/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:38:31.944802: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 135/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:39:40.049122: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 136/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:40:44.019811: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 137/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:41:52.088925: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 138/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:42:56.334351: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 194ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 139/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:44:06.334816: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 139: ReduceLROnPlateau reducing learning rate to 0.0025418657809495927.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0028\n", - "Epoch 140/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:45:16.401085: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0025\n", - "Epoch 141/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:46:24.535506: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0160 - val_loss: 0.0100 - learning_rate: 0.0025\n", - "Epoch 142/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:47:28.671105: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0099 - learning_rate: 0.0025\n", - "Epoch 143/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:48:38.905601: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0025\n", - "Epoch 144/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:49:41.633693: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0025\n", - "Epoch 145/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:50:51.459928: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0025\n", - "Epoch 146/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:52:01.529704: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0100 - learning_rate: 0.0025\n", - "Epoch 147/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:53:09.731786: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0025\n", - "Epoch 148/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:54:13.729067: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0025\n", - "Epoch 149/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:55:21.818772: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 149: ReduceLROnPlateau reducing learning rate to 0.0022876791190356016.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0025\n", - "Epoch 150/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:56:28.416496: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 151/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:57:35.906359: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 152/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:58:46.052264: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0160 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 153/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:59:54.781440: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 154/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:01:03.628026: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 155/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:02:08.109023: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 156/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:03:18.103931: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 157/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:04:28.232460: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 158/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:05:36.185931: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0160 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 159/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:06:43.863798: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 159: ReduceLROnPlateau reducing learning rate to 0.0020589112071320416.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0023\n", - "Epoch 160/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:07:50.555642: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 161/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:09:00.545640: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 162/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:10:10.751504: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 163/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:11:20.980133: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 164/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:12:31.119899: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 165/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:13:38.759507: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 166/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:14:48.584019: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0160 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 167/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:15:58.561385: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 168/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:17:09.863411: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 203ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 169/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:18:18.364582: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 169: ReduceLROnPlateau reducing learning rate to 0.0018530200235545636.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0021\n", - "Epoch 170/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:19:23.160844: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 171/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:20:33.117985: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 201ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 172/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:21:43.171847: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 173/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:22:53.286621: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 174/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:24:01.378798: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0099 - learning_rate: 0.0019\n", - "Epoch 175/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:25:06.148625: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 201ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 176/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:26:16.214117: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 177/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:27:27.416719: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 202ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 178/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:28:37.640110: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 179/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:29:45.715587: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 179: ReduceLROnPlateau reducing learning rate to 0.0016677180421538651.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0019\n", - "Epoch 180/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:30:49.832862: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 181/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:31:59.972537: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 182/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:33:08.125378: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 183/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:34:12.100031: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 184/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:35:22.065035: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 185/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:36:32.224188: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 186/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:37:39.997503: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 187/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0160" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:38:46.350523: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 188/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:39:54.017489: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 189/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:41:04.226814: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 189: ReduceLROnPlateau reducing learning rate to 0.0015009462484158575.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0017\n", - "Epoch 190/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:42:14.194799: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 191/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:43:22.224621: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 192/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:44:26.004181: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 193/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:45:34.099563: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 194/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:46:38.019325: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 195/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:47:47.975035: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 196/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:48:55.978740: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 197/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:50:00.082651: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 198/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:51:10.183364: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 199/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:52:18.066931: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 199: ReduceLROnPlateau reducing learning rate to 0.0013508516130968928.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 0.0015\n", - "Epoch 200/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:53:21.940617: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 201/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:54:30.004835: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 202/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:55:34.835174: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 203/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:56:44.555820: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 204/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:57:54.953011: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 205/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 01:59:03.074126: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 206/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:00:07.023292: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 207/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:01:16.895659: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 208/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:02:24.627878: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 209/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:03:28.505871: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 209: ReduceLROnPlateau reducing learning rate to 0.0012157664517872036.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0014\n", - "Epoch 210/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:04:36.548114: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 211/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:05:40.532683: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 212/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:06:50.899473: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 213/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:08:01.233850: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 214/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:09:09.445919: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 215/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:10:13.895674: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 216/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:11:23.360127: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 217/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:12:31.291076: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 218/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:13:36.464017: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 219/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:14:45.466539: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 219: ReduceLROnPlateau reducing learning rate to 0.0010941897751763463.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0012\n", - "Epoch 220/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:15:53.339084: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 191ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 221/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:16:58.569087: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 222/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:18:07.534452: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 223/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:19:15.373203: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 224/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:20:19.530027: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 225/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:21:27.639574: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 0.0011\n", - "Epoch 226/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:22:31.826661: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 227/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:23:39.716709: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 228/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:24:44.096777: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 200ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 229/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:25:52.346140: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 229: ReduceLROnPlateau reducing learning rate to 0.0009847708395682275.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 0.0011\n", - "Epoch 230/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:26:56.450489: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 9.8477e-04\n", - "Epoch 231/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:28:06.688818: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 200ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 9.8477e-04\n", - "Epoch 232/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:29:14.860386: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 9.8477e-04\n", - "Epoch 233/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:30:18.794061: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 9.8477e-04\n", - "Epoch 234/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:31:26.844756: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 9.8477e-04\n", - "Epoch 235/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:32:33.010784: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 9.8477e-04\n", - "Epoch 236/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:33:40.995334: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 9.8477e-04\n", - "Epoch 237/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:34:49.080415: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 9.8477e-04\n", - "Epoch 238/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:35:58.792227: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 9.8477e-04\n", - "Epoch 239/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:37:03.445446: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 239: ReduceLROnPlateau reducing learning rate to 0.0008862937451340258.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 195ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 9.8477e-04\n", - "Epoch 240/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:38:13.428347: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 8.8629e-04\n", - "Epoch 241/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:39:23.301722: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 8.8629e-04\n", - "Epoch 242/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:40:33.149090: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 8.8629e-04\n", - "Epoch 243/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:41:41.144014: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 8.8629e-04\n", - "Epoch 244/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:42:44.903818: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 8.8629e-04\n", - "Epoch 245/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:43:54.793683: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 8.8629e-04\n", - "Epoch 246/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:45:02.660801: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 8.8629e-04\n", - "Epoch 247/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:46:06.560764: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 8.8629e-04\n", - "Epoch 248/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:47:14.478530: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 8.8629e-04\n", - "Epoch 249/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:48:18.504643: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 249: ReduceLROnPlateau reducing learning rate to 0.0007976643915753812.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 8.8629e-04\n", - "Epoch 250/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:49:28.325964: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 251/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:50:36.263539: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 252/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:51:40.512231: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 253/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:52:48.707469: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 254/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:53:56.081265: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 255/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:55:02.829509: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 256/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:56:10.616624: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 257/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:57:14.585703: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 258/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:58:21.693788: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0100 - learning_rate: 7.9766e-04\n", - "Epoch 259/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:59:26.224931: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 259: ReduceLROnPlateau reducing learning rate to 0.0007178979576565325.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.9766e-04\n", - "Epoch 260/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 02:59:30.640623: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:00:34.259793: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 261/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:01:38.321850: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 262/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:02:46.385981: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 263/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:03:50.521521: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 264/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:05:00.246655: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0100 - learning_rate: 7.1790e-04\n", - "Epoch 265/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:06:10.263443: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 266/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:07:18.017861: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 191ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 267/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:08:19.793703: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 268/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:09:24.026886: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 269/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:10:31.536569: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 269: ReduceLROnPlateau reducing learning rate to 0.0006461081618908793.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 7.1790e-04\n", - "Epoch 270/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:11:35.502848: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 271/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:12:43.419397: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 272/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:13:47.289422: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 273/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:14:57.441552: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 274/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:16:05.584790: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 275/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:17:09.464575: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 276/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:18:17.599576: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 277/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:19:21.646498: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 278/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:20:30.163941: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 279/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:21:38.017632: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 279: ReduceLROnPlateau reducing learning rate to 0.0005814973614178598.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 6.4611e-04\n", - "Epoch 280/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:22:44.522185: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 281/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:23:52.719618: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 282/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:24:56.725912: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 283/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:26:04.820243: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 284/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:27:08.887552: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 285/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:28:17.003886: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 286/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:29:20.930006: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 287/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:30:29.077159: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 288/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:31:30.960762: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 289/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:32:34.939221: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 289: ReduceLROnPlateau reducing learning rate to 0.0005233476462308317.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 5.8150e-04\n", - "Epoch 290/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:33:43.088285: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 291/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:34:53.250395: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 292/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:35:57.094036: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 293/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:37:05.190288: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 294/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:38:09.266985: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 295/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:39:19.032377: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 296/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:40:27.234664: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 297/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:41:31.186921: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 298/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:42:39.291346: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 299/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:43:46.234634: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 299: ReduceLROnPlateau reducing learning rate to 0.0004710128763690591.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 5.2335e-04\n", - "Epoch 300/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:44:53.609590: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 301/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:46:03.735293: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 302/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:47:11.739027: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 303/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:48:15.421777: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 304/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:49:23.464985: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 305/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:50:27.392382: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 306/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:51:37.266355: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 307/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:52:45.173837: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 308/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:53:49.281490: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 309/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:54:58.606093: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 309: ReduceLROnPlateau reducing learning rate to 0.0004239115834934637.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.7101e-04\n", - "Epoch 310/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:56:08.564773: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 311/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:57:16.179790: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 191ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 312/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:58:18.114532: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 313/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:59:22.209516: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 314/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:00:30.144517: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 315/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:01:34.183406: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 316/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:02:44.398249: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 317/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:03:52.312063: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 318/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 176ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:04:56.125968: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 319/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:06:04.161265: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 319: ReduceLROnPlateau reducing learning rate to 0.0003815204225247726.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 4.2391e-04\n", - "Epoch 320/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 176ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:07:07.832860: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 321/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:08:15.805157: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 322/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:09:19.814708: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 323/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:10:27.894501: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 324/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:11:32.184523: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 325/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:12:41.193734: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 326/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:13:50.019100: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 191ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 327/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:14:54.513151: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 200ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 328/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:16:02.619180: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 329/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:17:08.075450: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 329: ReduceLROnPlateau reducing learning rate to 0.0003433683828916401.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 202ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.8152e-04\n", - "Epoch 330/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:18:26.528526: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m78s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 331/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:19:30.952447: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 332/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:20:40.689474: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 333/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:21:47.974838: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 334/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:22:58.513491: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 201ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 335/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:24:06.871105: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 336/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:25:11.025064: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 337/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:26:19.180091: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 338/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:27:23.330071: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 339/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:28:31.608042: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 339: ReduceLROnPlateau reducing learning rate to 0.0003090315498411656.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.4337e-04\n", - "Epoch 340/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:29:35.832680: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 341/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:30:44.312642: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 342/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:31:51.439191: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 343/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:32:56.962013: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 344/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:34:01.231995: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 345/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:35:09.687848: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 346/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:36:13.904140: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 347/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:37:22.045683: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 348/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:38:26.131024: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 349/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:39:34.191158: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 349: ReduceLROnPlateau reducing learning rate to 0.00027812838961835954.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 3.0903e-04\n", - "Epoch 350/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:40:38.782724: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 351/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:41:46.995637: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 352/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:42:57.384767: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 353/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:44:01.507621: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 354/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:45:09.888320: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 355/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:46:13.932367: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 356/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:47:22.141670: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 357/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:48:26.249891: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 358/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:49:36.399733: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 359/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:50:44.561464: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 359: ReduceLROnPlateau reducing learning rate to 0.00025031555851455777.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.7813e-04\n", - "Epoch 360/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:51:48.629247: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 361/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:52:56.976825: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 362/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:54:01.204759: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 363/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:55:09.641322: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.5032e-04\n", - "Epoch 364/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:56:13.744951: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 365/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:57:17.874432: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 366/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:58:24.169630: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 367/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 04:59:28.360796: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 368/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:00:36.483770: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 369/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:01:40.721105: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 369: ReduceLROnPlateau reducing learning rate to 0.00022528400004375725.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.5032e-04\n", - "Epoch 370/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:02:48.771570: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 371/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:03:53.171679: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 200ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 372/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:05:01.363494: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 373/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:06:05.575591: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2528e-04\n", - "Epoch 374/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:07:13.911493: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 375/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:08:18.044466: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 376/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:09:26.377511: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 377/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:10:30.460145: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 378/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:11:38.745956: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 379/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:12:42.003564: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 379: ReduceLROnPlateau reducing learning rate to 0.000202755605278071.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.2528e-04\n", - "Epoch 380/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:13:44.831272: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 381/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:14:53.093605: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 382/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:15:57.141991: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.0276e-04\n", - "Epoch 383/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:17:05.008004: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 384/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:18:07.168688: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 385/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:19:11.100464: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 386/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:20:19.680175: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 387/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:21:23.775656: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 388/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:22:31.935814: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 389/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:23:35.979772: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 389: ReduceLROnPlateau reducing learning rate to 0.00018248004344059154.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.0276e-04\n", - "Epoch 390/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:24:44.274247: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.8248e-04\n", - "Epoch 391/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:25:48.302020: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.8248e-04\n", - "Epoch 392/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:26:55.420375: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.8248e-04\n", - "Epoch 393/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:27:58.546605: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.8248e-04\n", - "Epoch 394/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:29:02.671107: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.8248e-04\n", - "Epoch 395/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:30:10.620240: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 1.8248e-04\n", - "Epoch 396/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:31:12.869508: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.8248e-04\n", - "Epoch 397/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:32:16.993641: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.8248e-04\n", - "Epoch 398/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:33:25.235187: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.8248e-04\n", - "Epoch 399/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:34:29.317968: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 399: ReduceLROnPlateau reducing learning rate to 0.00016423203778686004.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.8248e-04\n", - "Epoch 400/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:35:37.649398: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.6423e-04\n", - "Epoch 401/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:36:41.713871: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.6423e-04\n", - "Epoch 402/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:37:49.931840: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6423e-04\n", - "Epoch 403/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:38:53.949093: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.6423e-04\n", - "Epoch 404/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:40:02.048226: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6423e-04\n", - "Epoch 405/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:41:06.139671: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.6423e-04\n", - "Epoch 406/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:42:14.194948: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6423e-04\n", - "Epoch 407/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:43:16.324828: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.6423e-04\n", - "Epoch 408/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:44:20.423028: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.6423e-04\n", - "Epoch 409/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:45:28.625737: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 409: ReduceLROnPlateau reducing learning rate to 0.00014780883793719113.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6423e-04\n", - "Epoch 410/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:46:32.723721: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.4781e-04\n", - "Epoch 411/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:47:40.887297: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4781e-04\n", - "Epoch 412/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:48:45.078600: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.4781e-04\n", - "Epoch 413/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:49:52.999243: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.4781e-04\n", - "Epoch 414/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:50:57.262492: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.4781e-04\n", - "Epoch 415/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:52:05.380682: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.4781e-04\n", - "Epoch 416/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:53:07.419828: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.4781e-04\n", - "Epoch 417/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:54:09.925660: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4781e-04\n", - "Epoch 418/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:55:18.317597: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4781e-04\n", - "Epoch 419/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:56:24.104916: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 419: ReduceLROnPlateau reducing learning rate to 0.00013302795414347202.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4781e-04\n", - "Epoch 420/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:57:34.198545: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.3303e-04\n", - "Epoch 421/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:58:39.611512: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3303e-04\n", - "Epoch 422/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 05:59:46.269954: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3303e-04\n", - "Epoch 423/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:00:54.518018: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 1.3303e-04\n", - "Epoch 424/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:01:58.565232: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.3303e-04\n", - "Epoch 425/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:03:06.698336: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.3303e-04\n", - "Epoch 426/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:04:10.851741: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3303e-04\n", - "Epoch 427/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:05:19.122935: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3303e-04\n", - "Epoch 428/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:06:23.317663: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3303e-04\n", - "Epoch 429/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:07:33.600363: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 429: ReduceLROnPlateau reducing learning rate to 0.00011972515349043534.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3303e-04\n", - "Epoch 430/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:08:43.927531: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1973e-04\n", - "Epoch 431/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:09:52.154781: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1973e-04\n", - "Epoch 432/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:10:56.308741: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.1973e-04\n", - "Epoch 433/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:12:04.605733: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1973e-04\n", - "Epoch 434/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:13:08.577000: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1973e-04\n", - "Epoch 435/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:14:19.127690: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1973e-04\n", - "Epoch 436/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:15:28.030806: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.1973e-04\n", - "Epoch 437/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:16:35.153733: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1973e-04\n", - "Epoch 438/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:17:40.611305: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1973e-04\n", - "Epoch 439/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:18:43.750558: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 439: ReduceLROnPlateau reducing learning rate to 0.00010775263945106417.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1973e-04\n", - "Epoch 440/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:19:53.937083: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 200ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 441/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:21:02.016902: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 442/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:22:04.272435: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 443/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:23:10.338112: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 444/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:24:18.289959: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 445/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:25:25.841219: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 446/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:26:28.449489: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 447/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:27:32.492926: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 448/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:28:40.892369: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 449/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:29:45.123843: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 449: ReduceLROnPlateau reducing learning rate to 9.697737550595775e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0775e-04\n", - "Epoch 450/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:30:53.373643: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 451/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:31:57.770701: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 452/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:33:05.768687: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 453/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:34:09.937904: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 454/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:35:17.508664: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 455/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:36:20.410231: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 456/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:37:24.858683: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 457/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:38:30.304588: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 458/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:39:34.510891: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0101 - learning_rate: 9.6977e-05\n", - "Epoch 459/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:40:38.613628: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 459: ReduceLROnPlateau reducing learning rate to 8.727963795536197e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.6977e-05\n", - "Epoch 460/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:41:44.554732: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.7280e-05\n", - "Epoch 461/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:42:49.147047: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.7280e-05\n", - "Epoch 462/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:43:53.416779: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 8.7280e-05\n", - "Epoch 463/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:44:59.702711: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.7280e-05\n", - "Epoch 464/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:46:03.836298: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.7280e-05\n", - "Epoch 465/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:47:07.946415: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 8.7280e-05\n", - "Epoch 466/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:48:14.378366: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.7280e-05\n", - "Epoch 467/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:49:18.223008: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.7280e-05\n", - "Epoch 468/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:50:22.357264: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.7280e-05\n", - "Epoch 469/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:51:25.991981: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 469: ReduceLROnPlateau reducing learning rate to 7.85516735049896e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 8.7280e-05\n", - "Epoch 470/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:52:31.931658: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 471/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:53:34.692296: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.8552e-05\n", - "Epoch 472/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:54:38.827503: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 473/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:55:44.397590: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 474/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:56:48.986808: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 475/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:57:53.086874: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 476/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 06:58:59.464138: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 477/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:00:03.294023: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 478/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:01:07.488796: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 479/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:02:11.955524: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 479: ReduceLROnPlateau reducing learning rate to 7.0696507464163e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.8552e-05\n", - "Epoch 480/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:03:17.753109: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 481/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:04:19.867180: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 7.0697e-05\n", - "Epoch 482/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:05:23.940459: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 483/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:06:29.957315: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 484/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:07:34.079590: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 485/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:08:38.246955: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 486/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:09:41.364531: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 487/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:10:47.721823: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 488/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:11:50.633107: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 489/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:12:54.736665: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 489: ReduceLROnPlateau reducing learning rate to 6.36268567177467e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.0697e-05\n", - "Epoch 490/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:13:57.758481: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 491/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:15:02.615963: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 492/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:16:07.227266: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 493/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:17:09.480281: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 494/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:18:13.595485: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 495/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:19:16.012105: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 496/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:20:20.913662: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 6.3627e-05\n", - "Epoch 497/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:21:26.001487: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 498/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:22:28.833551: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 499/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:23:33.067252: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 499: ReduceLROnPlateau reducing learning rate to 5.726417366531678e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.3627e-05\n", - "Epoch 500/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:24:36.665087: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 501/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:25:43.336170: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 502/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:26:46.391179: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 503/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:27:49.627208: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 504/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:28:54.562273: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 505/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:29:59.623589: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 506/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:31:01.871548: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 507/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:32:05.696320: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 508/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:33:11.740420: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 509/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:34:15.834035: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 509: ReduceLROnPlateau reducing learning rate to 5.1537755643948914e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.7264e-05\n", - "Epoch 510/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:35:20.044695: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 511/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:36:24.120772: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 512/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:37:30.445184: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 513/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:38:34.573576: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 514/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:39:41.828290: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 515/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:40:44.820080: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 516/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:41:48.806530: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 517/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:41:53.194557: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:42:53.341441: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 518/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:43:58.851097: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 519/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:45:02.598727: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 519: ReduceLROnPlateau reducing learning rate to 4.638397876988165e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.1538e-05\n", - "Epoch 520/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:46:04.758037: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 521/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:47:10.177783: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 522/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:48:14.767863: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 523/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:49:18.888098: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 524/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:50:21.178552: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 525/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:51:26.314575: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 526/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:52:31.203997: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 527/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:53:33.539071: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 528/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:54:37.714768: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 529/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:55:41.768822: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 529: ReduceLROnPlateau reducing learning rate to 4.174558089289349e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.6384e-05\n", - "Epoch 530/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:56:47.854981: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 531/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:57:50.373122: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 532/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:58:54.766223: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 533/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 07:59:59.465059: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 534/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:01:04.016153: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 535/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:02:06.200903: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 536/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:03:10.259019: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 537/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:04:14.197612: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 538/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:05:20.381891: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 539/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:06:24.413008: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 539: ReduceLROnPlateau reducing learning rate to 3.7571023131022234e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1746e-05\n", - "Epoch 540/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:07:28.373480: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 541/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:08:34.440583: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 542/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:09:38.640576: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 543/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:10:44.068319: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 544/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:11:49.194326: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 545/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:12:53.541073: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 546/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:13:58.371902: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 547/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:15:04.078417: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 548/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:16:08.432635: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 200ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 549/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:17:11.759166: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 549: ReduceLROnPlateau reducing learning rate to 3.381392016308382e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.7571e-05\n", - "Epoch 550/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:18:18.818053: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 551/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:19:21.199381: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 552/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:20:25.514477: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 553/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:21:30.174598: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 554/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:22:36.205965: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 3.3814e-05\n", - "Epoch 555/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:23:40.517157: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 556/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:24:45.145135: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 557/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:25:50.990491: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 558/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:26:55.241216: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 559/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:28:00.198424: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 559: ReduceLROnPlateau reducing learning rate to 3.043252945644781e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3814e-05\n", - "Epoch 560/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:29:05.494879: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 561/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:30:09.659550: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 562/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:31:14.760485: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 563/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:32:19.945380: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 564/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:33:24.028567: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 565/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:34:27.609969: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 566/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:35:34.186608: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 567/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:36:38.263732: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 568/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:37:43.528331: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 569/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:38:48.460936: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 569: ReduceLROnPlateau reducing learning rate to 2.738927651080303e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.0433e-05\n", - "Epoch 570/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:39:52.358059: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 571/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:40:54.700203: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 572/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:42:01.076053: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 573/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:43:04.603639: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 574/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:44:08.851065: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 575/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:45:11.715203: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 576/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:46:17.651271: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 577/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:47:21.371530: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 578/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:48:25.364043: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 579/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:49:30.449933: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 579: ReduceLROnPlateau reducing learning rate to 2.4650348859722725e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.7389e-05\n", - "Epoch 580/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:50:35.605378: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 581/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:51:39.874616: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 582/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:52:44.621835: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 583/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:53:50.118190: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 584/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:54:54.315313: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 585/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:55:57.594357: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 586/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:57:04.740178: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 2.4650e-05\n", - "Epoch 587/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:58:07.185329: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 588/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 08:59:11.873296: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 589/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:00:17.639260: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 589: ReduceLROnPlateau reducing learning rate to 2.218531462858664e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4650e-05\n", - "Epoch 590/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:01:21.307388: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 591/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:02:23.713810: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 592/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:03:27.994344: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 593/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:04:32.632963: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 594/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:05:38.428991: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 595/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:06:42.394320: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 596/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:07:47.057909: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 597/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:08:52.775022: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 598/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:09:57.072133: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 599/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:11:01.395693: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 599: ReduceLROnPlateau reducing learning rate to 1.9966783656855114e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.2185e-05\n", - "Epoch 600/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:12:07.417065: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 601/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:13:11.564193: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 602/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:14:16.328778: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 603/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:15:22.554577: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 604/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:16:26.796058: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 605/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:17:31.125919: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 606/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:18:37.344709: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 607/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:19:41.554354: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 608/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:20:44.056119: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 609/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:21:49.794384: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 609: ReduceLROnPlateau reducing learning rate to 1.7970104636333417e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.9967e-05\n", - "Epoch 610/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:22:53.915551: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 611/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:23:58.162154: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 612/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:25:01.119623: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 613/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:26:05.988719: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 614/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:27:10.491535: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 615/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:28:13.026784: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 616/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:29:17.379382: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 200ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 617/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:30:21.494798: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 618/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:31:27.898822: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 619/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:32:32.168373: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 619: ReduceLROnPlateau reducing learning rate to 1.6173094991245307e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.7970e-05\n", - "Epoch 620/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:33:35.487382: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6173e-05\n", - "Epoch 621/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:34:41.146134: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6173e-05\n", - "Epoch 622/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:35:44.434747: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6173e-05\n", - "Epoch 623/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:36:48.702354: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6173e-05\n", - "Epoch 624/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:37:53.005174: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6173e-05\n", - "Epoch 625/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:38:58.245352: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6173e-05\n", - "Epoch 626/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:40:01.262852: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.6173e-05\n", - "Epoch 627/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:41:05.579772: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.6173e-05\n", - "Epoch 628/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:42:10.713298: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.6173e-05\n", - "Epoch 629/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:43:15.991362: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 629: ReduceLROnPlateau reducing learning rate to 1.4555785492120777e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.6173e-05\n", - "Epoch 630/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:44:20.142702: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 631/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:45:24.266908: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 632/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:46:30.336414: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 633/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:47:34.484339: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 634/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:48:39.980770: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 635/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:49:45.036296: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 636/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:50:47.680574: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 637/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:51:51.364936: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 638/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:52:54.826369: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 639/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:54:00.216820: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 639: ReduceLROnPlateau reducing learning rate to 1.3100206615490606e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.4556e-05\n", - "Epoch 640/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:55:03.892348: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 641/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:56:06.199356: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 642/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:57:10.395737: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 643/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:58:13.439558: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 644/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 09:59:20.772184: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 645/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:00:22.985739: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 646/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:01:27.206289: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 647/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:02:33.048398: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 648/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:03:37.367667: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 649/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:04:41.512124: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 649: ReduceLROnPlateau reducing learning rate to 1.1790186363214161e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.3100e-05\n", - "Epoch 650/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:05:48.240842: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 651/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:06:52.038972: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 652/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:07:56.203750: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 653/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:09:01.168309: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0101 - learning_rate: 1.1790e-05\n", - "Epoch 654/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:10:06.572000: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 655/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:11:10.857198: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 656/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:12:14.646634: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 657/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:13:20.834125: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 658/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:14:23.603287: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 659/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:15:26.400451: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 659: ReduceLROnPlateau reducing learning rate to 1.0611167726892746e-05.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.1790e-05\n", - "Epoch 660/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:16:30.053505: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 661/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:17:35.664435: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 662/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:18:40.291054: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 663/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:19:44.532614: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 664/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:20:47.823297: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 665/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:21:53.239598: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 666/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:22:57.070533: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 667/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:24:01.236480: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 668/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:25:05.281928: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 669/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:26:11.469271: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 669: ReduceLROnPlateau reducing learning rate to 9.550050708639902e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 1.0611e-05\n", - "Epoch 670/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:27:13.755848: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0157 - val_loss: 0.0101 - learning_rate: 9.5501e-06\n", - "Epoch 671/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:28:17.815626: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 672/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:29:21.817372: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 673/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:30:27.485669: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 674/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:31:30.604861: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 675/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:32:34.723848: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 676/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:33:40.066280: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 677/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:34:45.053367: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 678/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:35:49.234581: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 679/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:36:52.567520: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 679: ReduceLROnPlateau reducing learning rate to 8.595045801484958e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 9.5501e-06\n", - "Epoch 680/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:37:59.306881: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 681/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:39:02.454249: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 682/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:40:05.700931: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 683/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:41:13.089646: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 684/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:42:15.824185: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 685/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:43:19.896758: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 686/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:44:24.650842: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 687/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:45:29.989039: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 688/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:46:34.101519: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 689/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:47:38.081460: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 689: ReduceLROnPlateau reducing learning rate to 7.735541385045509e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 8.5950e-06\n", - "Epoch 690/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:48:44.374308: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 691/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:49:48.404243: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 692/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:50:53.092713: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 693/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:51:58.602931: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 694/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:53:02.646625: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 695/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:54:06.673112: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 696/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:55:13.028339: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 697/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:56:17.091354: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 698/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:57:21.573331: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 699/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:58:27.289881: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 699: ReduceLROnPlateau reducing learning rate to 6.961987492104527e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 7.7355e-06\n", - "Epoch 700/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 10:59:31.325523: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 701/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:00:35.238896: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 702/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:01:41.313820: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 703/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:02:45.423909: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 704/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:03:50.206998: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 705/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:04:55.509467: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 706/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:05:58.954463: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 707/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:07:01.920456: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 708/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:08:08.532767: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 709/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:09:12.082227: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 709: ReduceLROnPlateau reducing learning rate to 6.265788579185028e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.9620e-06\n", - "Epoch 710/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:10:16.571636: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 200ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 711/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:11:21.471432: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 712/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:12:26.801878: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 713/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:13:30.906376: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 714/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:14:33.307407: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 715/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:15:38.602667: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 716/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:16:43.455145: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 717/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:17:45.645647: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 718/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:18:49.750938: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 719/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:19:56.158115: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 719: ReduceLROnPlateau reducing learning rate to 5.639209803121048e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 6.2658e-06\n", - "Epoch 720/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:21:00.041190: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 721/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:22:04.319051: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 722/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:23:11.376394: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 723/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:24:14.438678: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 724/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:25:16.620536: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 725/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:26:20.476453: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 726/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:27:24.058966: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 727/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:28:29.679499: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 728/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:29:32.632608: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 729/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:30:36.718588: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 729: ReduceLROnPlateau reducing learning rate to 5.075289027445251e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.6392e-06\n", - "Epoch 730/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:31:40.728026: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 731/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:32:46.792380: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 732/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:33:50.680387: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 733/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:34:55.467989: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 734/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:36:00.500165: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 735/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:37:04.512375: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 736/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:38:10.184150: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 737/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:39:14.611602: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 738/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:40:16.762061: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 739/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:41:20.460437: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 739: ReduceLROnPlateau reducing learning rate to 4.567760288409772e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 5.0753e-06\n", - "Epoch 740/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:42:24.152165: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 741/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:43:29.959987: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 742/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:44:32.568404: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 743/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:45:34.694017: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 744/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:46:38.808458: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 745/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:47:44.477596: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 746/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:48:49.095199: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 747/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:49:53.027700: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 195ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 748/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:51:00.676230: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 749/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:52:03.181007: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 749: ReduceLROnPlateau reducing learning rate to 4.110984218641534e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.5678e-06\n", - "Epoch 750/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:53:07.263060: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 751/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:54:10.692335: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 752/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:55:16.425168: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 753/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:56:19.419739: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 754/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:57:23.064055: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 755/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:58:25.349002: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 756/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 11:59:32.385024: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 757/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:00:35.781715: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 758/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:01:39.913746: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 759/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:02:47.601537: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 759: ReduceLROnPlateau reducing learning rate to 3.6998858377046417e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 4.1110e-06\n", - "Epoch 760/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:03:49.843814: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 761/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:04:54.472351: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 762/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:05:59.710335: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 763/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:07:03.966699: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 764/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:08:07.973147: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 765/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:09:11.673736: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 766/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:10:17.959055: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 767/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:11:22.048279: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 768/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:12:26.588852: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 769/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:13:32.059083: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 769: ReduceLROnPlateau reducing learning rate to 3.3298972539341776e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.6999e-06\n", - "Epoch 770/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:14:36.072133: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 771/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:15:40.360505: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 772/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:16:45.903069: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 192ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 773/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:17:49.916543: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 774/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:18:53.178524: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 775/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:19:58.167626: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 776/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:21:02.027756: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 777/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:22:05.345929: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 196ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 778/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:23:08.162708: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 194ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 779/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:24:15.889648: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 779: ReduceLROnPlateau reducing learning rate to 2.99690752854076e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 3.3299e-06\n", - "Epoch 780/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:25:18.464191: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 781/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:26:22.604730: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 197ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 782/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:27:27.474297: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 783/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:28:32.914664: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 784/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:29:35.101811: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m62s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 785/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:30:39.051694: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 786/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:31:44.523646: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 787/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:32:49.047896: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 788/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:33:53.214724: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 789/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate the dynamic Huber loss\n", + "dynamic_huber_loss = DynamicHuberLoss(initial_delta=1.0, final_delta=0.1, total_epochs=1000)\n", + "\n", + "\n", + "\n", + "# Create a custom callback to update the epoch\n", + "class UpdateEpochCallback(tf.keras.callbacks.Callback):\n", + " def __init__(self, loss_fn):\n", + " super().__init__()\n", + " self.loss_fn = loss_fn\n", + " self.current_epoch = 0\n", + "\n", + " def on_epoch_begin(self, epoch, logs=None):\n", + " self.loss_fn.update_epoch(epoch)\n", + "\n", + "# Instantiate the callback\n", + "update_epoch_callback = UpdateEpochCallback(dynamic_huber_loss)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:34:56.509567: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] + "data": { + "text/html": [ + "
Model: \"functional\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"functional\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 789: ReduceLROnPlateau reducing learning rate to 2.697216837077576e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m63s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.9969e-06\n", - "Epoch 790/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ input_layer (InputLayer)        │ (None, 64, 64, 1)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d (Conv2D)                 │ (None, 64, 64, 64)     │           640 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (MaxPooling2D)    │ (None, 32, 32, 64)     │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization             │ (None, 32, 32, 64)     │           256 │\n",
+       "│ (BatchNormalization)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (Conv2D)               │ (None, 32, 32, 64)     │        36,928 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_2 (Conv2D)               │ (None, 32, 32, 128)    │        73,856 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_3 (Conv2D)               │ (None, 32, 32, 128)    │       147,584 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout (Dropout)               │ (None, 32, 32, 128)    │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_1           │ (None, 32, 32, 128)    │           512 │\n",
+       "│ (BatchNormalization)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_4 (Conv2D)               │ (None, 32, 32, 256)    │       295,168 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_5 (Conv2D)               │ (None, 32, 32, 256)    │       590,080 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_1 (Dropout)             │ (None, 32, 32, 256)    │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_2           │ (None, 32, 32, 256)    │         1,024 │\n",
+       "│ (BatchNormalization)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_6 (Conv2D)               │ (None, 32, 32, 512)    │     1,180,160 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_2 (Dropout)             │ (None, 32, 32, 512)    │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_7 (Conv2D)               │ (None, 32, 32, 512)    │     2,359,808 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_8 (Conv2D)               │ (None, 32, 32, 512)    │     2,359,808 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (MaxPooling2D)  │ (None, 16, 16, 512)    │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (Dropout)             │ (None, 16, 16, 512)    │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_9 (Conv2D)               │ (None, 16, 16, 256)    │     3,277,056 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_2 (MaxPooling2D)  │ (None, 8, 8, 256)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_3           │ (None, 8, 8, 256)      │         1,024 │\n",
+       "│ (BatchNormalization)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_4 (Dropout)             │ (None, 8, 8, 256)      │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ global_average_pooling2d        │ (None, 256)            │             0 │\n",
+       "│ (GlobalAveragePooling2D)        │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ x_midpoints (Dense)             │ (None, 10)             │         2,570 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ x_midpoints_reshape (Reshape)   │ (None, 1, 5, 2)        │             0 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m640\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ batch_normalization │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m36,928\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m147,584\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ batch_normalization_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_4 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m295,168\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_5 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m590,080\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout_1 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ batch_normalization_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,024\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_6 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m1,180,160\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout_2 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_7 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m2,359,808\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_8 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m2,359,808\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout_3 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv2d_9 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m3,277,056\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling2d_2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ batch_normalization_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,024\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout_4 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ global_average_pooling2d │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "│ (\u001b[38;5;33mGlobalAveragePooling2D\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ x_midpoints (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m2,570\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ x_midpoints_reshape (\u001b[38;5;33mReshape\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:36:03.248372: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] + "data": { + "text/html": [ + "
 Total params: 10,326,474 (39.39 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m10,326,474\u001b[0m (39.39 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 791/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0158" - ] + "data": { + "text/html": [ + "
 Trainable params: 10,325,066 (39.39 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m10,325,066\u001b[0m (39.39 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:37:07.235618: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" - ] - }, + "data": { + "text/html": [ + "
 Non-trainable params: 1,408 (5.50 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m1,408\u001b[0m (5.50 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# dynamic_exponent_callback = DynamicExponentCallback(1, 1, 50)\n", + "\n", + "\n", + "with strategy.scope():\n", + " # Instantiate the model builder\n", + " model_builder = ModelBuilder()\n", + "\n", + " # Build the model\n", + " model_builder.build_model()\n", + "\n", + " # Display the model architecture\n", + " model_builder.model.summary()\n", + "\n", + " # Compile the model using the custom loss function\n", + " # model_builder.compile_model(loss_function=dynamic_exponent_callback.custom_loss(1))\n", + " # model_builder.compile_model(loss_function=tf.keras.losses.MeanSquaredError()) \n", + " model_builder.compile_model(loss_function=tf.keras.losses.Huber()) \n", + "\n", + "\n", + "\n", + "# # Instantiate the model builder\n", + "# model_builder = ModelBuilder()\n", + "\n", + "# # Build the model\n", + "# model_builder.build_model()\n", + "\n", + "# # Display the model architecture\n", + "# model_builder.model.summary()\n", + "\n", + "# # Compile the model using the custom loss function\n", + "# # model_builder.compile_model(loss_function=dynamic_exponent_callback.custom_loss(1))\n", + "# # model_builder.compile_model(loss_function=tf.keras.losses.MeanSquaredError()) \n", + "# model_builder.compile_model(loss_function=tf.keras.losses.Huber()) " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 792/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" + "Epoch 1/251\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2024-09-20 12:38:10.918708: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "2024-09-24 19:08:57.545777: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:966] layout failed: INVALID_ARGUMENT: Size of values 0 does not match size of permutation 4 @ fanin shape inStatefulPartitionedCall/cond/else/_378/cond/StatefulPartitionedCall/functional_1/dropout_1/stateless_dropout/SelectV2-2-TransposeNHWCToNCHW-LayoutOptimizer\n", + "2024-09-24 19:09:01.099959: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-09-24 19:09:01.111656: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "2024-09-24 19:09:01.140231: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1727204941.195573 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.204640 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.204851 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.238344 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.238362 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.238489 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.238903 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.241924 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.242180 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.242498 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.242573 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.242836 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.243282 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.243337 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.243478 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.243848 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.244116 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.245324 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.245926 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.246166 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.246525 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.246708 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.246910 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.247307 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.247411 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.247608 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.248061 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.248176 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.248379 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.248772 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.252047 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.252165 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.252435 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.252694 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.252931 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.253190 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.253297 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.253498 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.253770 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.253884 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.254107 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.254404 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.254731 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.255045 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.255432 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.255515 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.255773 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.256288 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.256402 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.256604 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.257099 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.268701 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.269315 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.269396 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.269566 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.270446 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.270488 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.270577 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.271719 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.271724 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.271734 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.272819 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.272918 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.272929 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.274014 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.274169 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.294380 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.294461 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.295844 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.297847 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.297991 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.298153 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.298446 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.298692 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.298905 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.299092 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.299462 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.299778 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.328830 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.328857 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.328880 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.336655 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.336665 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.336683 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.338911 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.339047 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.339147 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.341168 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.341366 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.341567 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.343767 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.343951 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.343973 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.344663 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.344826 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.344842 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.347199 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.347312 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.347394 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.349426 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.349546 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.349660 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.351446 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.351675 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.351773 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.354070 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.354206 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.354223 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.362614 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.362770 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.362787 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.716374 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.719996 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.720494 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.720990 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.721527 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.721987 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.722481 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.730120 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.732676 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.735138 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.737602 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.739544 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.741815 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.744020 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.786481 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.786923 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.787407 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.787910 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.788421 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.790117 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.790706 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.791284 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.791836 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.792397 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.793648 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.795454 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.797260 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.799096 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.800823 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.801570 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.802288 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.803456 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.804509 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.806379 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.807706 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.816206 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.816769 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.817307 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.817910 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.818447 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.819039 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.819561 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.820159 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.820729 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.821519 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.822227 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.822994 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.825212 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.827534 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.829772 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.834281 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.838809 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.841659 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.844528 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.931619 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.932216 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.932820 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.933437 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.934064 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.934676 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.935306 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.935995 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.936706 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.937452 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.938252 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.939026 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.939856 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.940810 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.941800 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.942836 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.943966 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.945118 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.946869 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.954967 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.957485 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.966753 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.967546 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.968321 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.969252 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.970161 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.970981 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.971773 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.972517 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.973385 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.974657 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.975816 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.977055 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.978545 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.979869 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.980331 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.980601 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.980847 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.981372 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.981835 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.982325 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.984392 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.984967 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.986400 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.988835 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.989219 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.991314 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.993283 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.995562 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.997932 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204941.998053 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.003347 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.008674 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.009997 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.010460 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.010964 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.011489 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.012075 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.012183 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.012577 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.014034 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.016015 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.017571 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.018500 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.021010 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.022979 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.025264 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.027494 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.040775 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.041230 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.041713 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.042230 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.042749 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.043510 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.044087 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.044665 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.045227 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.045788 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.046516 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.047350 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.048219 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.049164 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.050010 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.050744 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.051463 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.052623 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.053681 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.055546 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.056884 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.065277 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.065843 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.066372 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.066980 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.067517 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.068119 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.068640 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.069239 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.069824 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.070426 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.070628 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.070883 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.071495 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.071579 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.072106 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.072306 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.072638 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.073385 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.073968 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.074665 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.074739 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.075301 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.075864 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.076592 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.077071 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.077427 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.078262 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.079233 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.079584 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.080093 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.080829 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.081549 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.082714 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.083770 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.084138 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.085650 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.087000 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.088703 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.091538 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.094409 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.095257 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.095836 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.096365 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.096973 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.097521 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.098115 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.098635 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.099231 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.099802 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.100593 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.101313 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.102078 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.104294 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.106637 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.108895 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.113460 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.118026 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.120871 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.123767 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.179607 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.180198 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.180795 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.181402 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.182044 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.182658 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.183284 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.183973 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.184680 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.185424 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.185801 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.186230 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.186674 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.187012 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.187553 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.187863 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.188379 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.188825 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.189268 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.189832 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.190226 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.190888 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.191138 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.192212 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.192230 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.193424 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.193521 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.194637 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.195303 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.195740 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.196851 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.197754 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.197967 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.199356 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.200277 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.200886 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.202453 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.204172 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.206011 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.209358 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.209558 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.209577 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.210295 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.210322 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.210969 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.211134 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.211589 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.212111 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.212288 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.212941 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.213122 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.213586 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.213963 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.214410 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.214515 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.214775 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.215129 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.215536 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.215881 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.216416 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.216695 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.217468 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.217718 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.218320 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.218944 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.219036 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.219280 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.220404 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.220478 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.221456 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.222584 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.223924 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.224099 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.226082 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.228591 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.228669 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.231116 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.232938 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.238243 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.240218 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.241032 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.241808 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.242740 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.243656 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.244479 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.245280 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.246026 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.246935 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.247104 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.248232 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.249353 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.250591 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.254167 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.255932 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.258562 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.261327 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.262825 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.271659 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.277002 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.285851 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.291271 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.430751 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.431620 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.432495 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.433312 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.434185 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.435139 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.436046 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.436961 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.438010 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.439222 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.440309 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.441427 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.442522 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.443920 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.445438 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.447008 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.448724 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.450564 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.453919 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.458729 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.461374 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.462229 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.463105 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.463207 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.464016 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.464893 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.465836 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.466735 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.467647 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.468728 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.470144 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.471229 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.472347 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.473452 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.474855 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.476375 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.477970 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.479691 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.481534 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.484890 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.489717 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.494035 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.661596 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.662819 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.664125 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.665603 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.666888 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.668471 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.669815 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.671397 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.672831 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.674161 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.675608 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.677123 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.683743 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.690447 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.699041 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.707375 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.716336 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.725466 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.743209 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.892659 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.893913 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.895091 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.896400 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.897543 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.898968 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.900133 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.901559 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.902829 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.903994 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.905295 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.906640 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.913065 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.919680 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.928162 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.936383 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.936421 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.937657 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.938833 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.940151 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.941266 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.942686 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.943856 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.945438 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.945460 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.946727 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.947883 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.949171 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.950495 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.954454 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.956968 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.963585 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.972092 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.972472 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.980354 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.989247 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204942.998328 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.016244 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.080585 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.081904 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.083254 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.084512 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.085868 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.087369 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.088800 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.090259 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.091962 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.093968 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.095735 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.097574 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.099398 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.101790 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.104416 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.107240 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.110292 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.113624 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.119764 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.128256 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.143036 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.145036 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.147117 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.149426 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.151421 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.153938 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.155948 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.158484 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.160394 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.162384 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.164628 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.166983 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.178562 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.191594 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.208578 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.224912 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.242132 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.260378 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.297670 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.311551 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.312876 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.314246 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.315531 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.316904 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.318426 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.319869 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.321345 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.323047 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.325062 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.326843 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.328673 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.330501 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.332892 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.335563 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.338367 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.341433 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.344801 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.351008 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.357267 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.358586 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.359577 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.359955 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.361221 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.362588 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.364095 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.365535 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.367005 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.368861 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.370891 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.372684 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.374522 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.374612 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.376353 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.376642 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.378868 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.378944 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.381222 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.381597 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.383249 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.384422 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.385795 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.387470 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.387841 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.390413 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.390815 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.392360 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.394356 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.396621 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.396952 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.398997 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.405441 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.410692 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.420250 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.422247 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.423942 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.424331 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.426628 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.428619 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.431122 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.433134 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.435656 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.437560 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.439534 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.440982 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.441803 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.444138 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.455696 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.457408 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.468866 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.474753 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.486021 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.493021 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.502504 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.519881 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.532743 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.538450 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.576873 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.971672 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.973832 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.975992 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.978173 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.980493 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.982892 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.985287 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.987801 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.990393 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.993342 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.996390 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204943.999488 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.002766 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.007318 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.011770 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.016518 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.022418 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.028657 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.050782 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.054289 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.057824 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.062351 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.066032 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.069597 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.073061 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.077356 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.082263 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.085879 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.090154 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.094639 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.118009 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.144991 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.178475 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.210117 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.210264 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.212305 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.214483 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.216673 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.218999 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.221415 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.223808 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.226345 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.228931 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.231835 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.234866 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.237935 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.241197 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.242186 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.245740 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.250341 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.255082 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.261116 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.261185 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.263371 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.265551 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.267439 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.267744 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.270091 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.272491 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.274913 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.277567 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.277677 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.280208 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.283146 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.286211 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.288940 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.289391 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.292585 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.292789 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.296258 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.297451 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.300948 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.302042 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.304715 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.306769 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.308392 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.311911 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.312659 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.316189 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.318897 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.321055 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.324649 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.328940 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.333509 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.341811 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.345353 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.348895 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.353386 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.356706 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.357129 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.357194 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.360754 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.364165 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.368253 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.373253 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.376986 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.381398 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.384440 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.385999 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.410071 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.418077 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.437484 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.450073 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.471209 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.482209 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.503310 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.516059 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.534915 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.570661 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.590351 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204944.650268 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.699607 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.703425 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.707296 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.711207 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.715347 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.719667 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.724017 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.728853 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.733806 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.739397 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.745463 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.751763 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.758399 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.767573 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.777087 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.786787 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.798390 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.810780 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.846443 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.853702 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.860516 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.867413 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.876714 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.883947 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.892264 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.899117 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.908740 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.915655 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.923915 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.932805 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.938990 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.942843 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.946750 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.950701 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.954854 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.959235 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.963746 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.968496 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.973358 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.976755 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.978897 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.985105 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.991406 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204945.998127 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.005638 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.007375 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.009440 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.013296 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.016889 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.017206 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.021361 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.025679 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.026459 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.028342 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.030010 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.034609 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.038201 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.039300 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.044974 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.050703 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.051075 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.057270 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.063980 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.073196 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.082638 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.087515 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.092282 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.093534 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.094450 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.101498 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.104105 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.108687 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.116690 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.117939 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.125078 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.133411 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.140258 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.149849 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.151356 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.156905 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.156988 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.158887 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.165241 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.165800 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.172675 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.174143 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.181658 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.188755 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.196997 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.203807 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.213310 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.218046 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.220174 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.221810 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.228373 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.237168 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.270107 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.281333 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.294045 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.333030 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.335534 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.398775 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.398887 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.439522 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.462302 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.464244 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.528425 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.542496 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.607583 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.689634 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204946.752031 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.130582 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.137405 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.144169 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.151443 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.159374 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.167082 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.175593 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.184842 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.194059 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.203769 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.215568 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.227494 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.240130 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.258377 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.275050 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.291739 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.313617 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.355672 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.358421 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.361403 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.364940 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.367945 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.370564 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.373492 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.376662 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.380383 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.383556 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.386210 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.387320 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.393122 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.393590 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.399959 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.407273 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.414980 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.417776 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.423017 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.431677 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.438016 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.441161 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.450461 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.460434 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.460500 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.460966 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.467354 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.472246 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.474145 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.481395 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.484046 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.484700 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.489714 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.497014 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.497885 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.506514 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.508283 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.515607 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.516138 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.525487 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.532588 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.534378 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.535440 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.547155 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.549537 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.558856 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.571488 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.571767 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.589617 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.612311 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.614114 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.616788 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.619689 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.623183 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.626177 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.628935 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.629066 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.631899 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.635103 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.638860 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.642066 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.645860 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.650799 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.652138 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.676458 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.692644 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.695330 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.696700 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.698261 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.701738 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.704679 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.707257 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.710158 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.713301 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.716981 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.719685 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.720160 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.723920 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.730168 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.743256 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.754282 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.766606 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.774531 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.792083 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.797627 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.821378 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.844870 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204949.870892 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.375504 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.378117 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.380588 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.383199 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.385891 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.388678 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.391479 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.394472 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.398049 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.401794 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.406254 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.411512 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.416832 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.422325 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.429229 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.435483 1395955 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.637354 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.640158 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.642845 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.645666 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.648549 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.651539 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.654522 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.657738 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.661485 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.665261 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.669751 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.675085 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.680483 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.685964 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.692854 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.699042 1395886 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.717329 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.719950 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.722426 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.725039 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.727764 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.730557 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.733371 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.736383 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.739971 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.743582 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.747897 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.753095 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.758534 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.764075 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.770714 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.771038 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.774333 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.776624 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.777327 1395941 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.779121 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.781604 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.785688 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.790039 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.792373 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.795302 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.798232 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.801574 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.805404 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.811222 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.829705 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.847495 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.864739 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.885439 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204950.903532 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.742581 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.744948 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.747493 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.749954 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.752500 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.756715 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.760581 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.763461 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.767455 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.772189 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.777103 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.780439 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.783966 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.787908 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.792038 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.797629 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.803473 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.806517 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.808203 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.809126 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.809402 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.810951 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.811900 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.813438 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.814614 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.815054 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.816018 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.817195 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.818554 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.819989 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.821342 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.822443 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.823796 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.824818 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.826144 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.827761 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.829101 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.830729 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.832070 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.834111 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.835452 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.837988 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.839326 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.843905 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.845251 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.856596 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.860805 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.862453 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.863731 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.864150 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.867474 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.870791 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.874088 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.877385 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.880491 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.880721 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.881656 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.884009 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.887076 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.890141 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.894557 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.898018 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.898129 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.899047 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.901611 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.908994 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.913298 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.917601 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.918474 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.919403 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.921938 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.926249 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.930556 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.934863 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.936738 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.939955 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.939961 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.946412 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.950757 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.956361 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.976180 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204951.994492 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.014699 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.036886 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.058178 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.768001 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.770366 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.772931 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.775414 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.775762 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204952.778056 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.178739 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.180979 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.181609 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.183878 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.184116 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.186814 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.186826 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.190259 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.190258 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.723801 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.724878 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.727984 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.728011 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.731328 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.731399 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.735026 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.735053 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.738931 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.739397 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.742180 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.743401 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.745624 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.747537 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.749440 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.751841 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.753492 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.757373 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.757627 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.761913 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.763144 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.767518 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.773349 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.794756 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.798190 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.801636 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.805023 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.805239 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.808371 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.808696 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.811720 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.812066 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.815070 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.815470 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.818413 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.818845 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.821751 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.822213 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.824862 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.825583 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.827959 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.828941 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.832302 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.832509 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.835436 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.835896 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.838560 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.839572 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.843064 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.846413 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.846987 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.850062 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.851391 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.855735 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.857514 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.860135 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.861856 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.864494 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.866209 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.868863 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.870626 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.873277 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.875029 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.876726 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.879421 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.879934 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.883838 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.884283 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.887262 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.889907 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.890479 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.894797 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.900422 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.908745 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.919087 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.927074 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.937426 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.947104 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.957798 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.968760 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.979654 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204953.990319 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.001170 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.718603 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.721283 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.724348 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.727518 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.730728 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.735215 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.740259 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.745848 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.752260 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.757904 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.764664 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.768972 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.926163 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.957018 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.965768 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.972078 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.978567 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.984933 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.991448 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204954.998392 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.005696 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.014387 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.021141 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.027970 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.037581 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.047505 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.057021 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.067863 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.110863 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.163177 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.214376 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.262508 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.319397 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204955.368603 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.605361 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.608070 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.611170 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.614374 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.617622 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.622038 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.627077 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.631849 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.633365 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.636075 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.637553 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.639170 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.642366 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.643288 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.645616 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.650099 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.650270 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.653750 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.655183 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.659953 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.665498 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.671127 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.673260 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.677906 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.681345 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.700850 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.704425 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.714103 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.720456 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.726973 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.732090 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.736216 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.741880 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.743280 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.748343 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.750315 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.754931 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.757672 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.761392 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.765597 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.768077 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.772354 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.775117 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.779261 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.782549 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.788823 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.790578 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.797500 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.798635 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.804527 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.808097 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.814172 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.818926 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.824208 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.833837 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.844901 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.861730 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.889939 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.912309 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.941127 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.963808 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204956.992315 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204957.012842 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204957.041082 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204957.070777 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204957.099192 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204957.120541 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204957.148989 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.004218 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.010748 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.017387 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.024196 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.031481 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.039057 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.046738 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.055142 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.063570 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.072201 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.081757 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.091729 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.101661 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.113404 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.126141 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.138537 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.151096 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.167528 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.185124 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.207956 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.273548 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.282635 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.291698 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.301769 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.311860 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.322118 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.334735 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.346715 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.358721 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.371978 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.385260 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.401334 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.414218 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.427073 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.439902 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.451881 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.465918 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.478688 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.514918 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.529645 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.546458 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.603710 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.660999 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.712705 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.764673 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.818032 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204958.880259 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.762256 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.768798 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.775471 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.782305 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.789639 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.797067 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.804993 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.810453 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.813598 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.817005 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.822327 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.823706 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.830574 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.831303 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.837925 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.841173 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.845307 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.851441 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.852695 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.861337 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.861624 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.869874 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.873514 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.878654 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.886346 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.888305 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.898321 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.898994 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.908254 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.911550 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.919946 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.927852 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.932776 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.945233 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.945414 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.957859 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.968469 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.974354 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204959.992031 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.014858 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.033867 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.042947 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.051971 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.062044 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.072243 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.079854 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.082568 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.088892 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.095811 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.097932 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.108090 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.108209 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.118132 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.120457 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.128367 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.133858 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.140981 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.147218 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.152969 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.163219 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.165083 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.176074 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.178354 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.188935 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.191686 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.201838 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.207883 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.213924 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.221024 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.228104 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.234005 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.240960 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.246965 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.259014 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.273143 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.276407 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.286030 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.291058 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.307792 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.321371 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.336188 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.352979 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.365355 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.411233 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.417197 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.468988 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.469490 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.521833 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.527870 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.574721 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.581409 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.629187 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.641802 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204960.691863 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.368284 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.375445 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.383717 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.392607 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.401783 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.414146 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.427713 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.442716 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.459329 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.476999 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.497038 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.509936 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.577953 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.604563 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.608426 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.612347 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.616293 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.620455 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.624097 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.627922 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.631734 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.635456 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.640401 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.644119 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.649011 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.654119 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.659812 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.681992 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.707925 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.733323 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.759928 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.789780 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204983.815237 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.865871 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.873133 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.881556 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.890454 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.900201 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.913096 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.927256 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.942737 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.959640 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.977695 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204984.998300 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.011493 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.079379 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.107057 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.110860 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.114736 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.118804 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.123138 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.125436 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.126940 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.130931 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.132652 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.134821 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.135121 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.138631 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.139197 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.140956 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.142463 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.144550 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.146323 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.148581 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.149693 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.150474 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.154051 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.154536 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.158575 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.159203 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.159677 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.163195 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.165943 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.167788 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.171764 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.172505 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.177589 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.182993 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.185698 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.188467 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.189619 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.194830 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.200971 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.201788 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.208654 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.215617 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.216703 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.217513 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.224615 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.234388 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.235148 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.242256 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.246787 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.255338 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.268405 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.268964 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.282596 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.287601 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.292559 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.297585 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.299419 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.302572 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.307270 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.312200 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.317731 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.323345 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.325631 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.329354 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.334205 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.336139 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.341424 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.348091 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.354747 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.362455 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.363146 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.366903 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.369077 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.370802 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.374833 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.375922 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.379146 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.382898 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.385040 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.386874 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.390834 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.392464 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.394802 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.400074 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.400289 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.404026 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.409260 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.414734 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.420867 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.425641 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.444407 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.446048 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.454208 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.467949 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.470871 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.479651 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.496042 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.506029 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.522532 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.532284 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.552506 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.558454 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.578250 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.588125 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.614725 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204985.641318 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.648359 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.652145 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.655989 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.659865 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.664010 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.668107 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.672238 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.676725 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.681098 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.685624 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.690959 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.696480 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.702053 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.708441 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.715494 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.722480 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.729506 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.738509 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.748365 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.760960 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.797478 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.802569 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.807623 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.812741 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.817800 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.822569 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.827603 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.833381 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.840560 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.846561 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.851413 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.858593 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.865229 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.871810 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.879394 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.885945 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.892723 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.901822 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.909318 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.909465 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.913270 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.916822 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.917110 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.920951 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.925062 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.929099 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.933153 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.937566 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.941997 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.942090 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.946829 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.952063 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.957482 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.962272 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.962950 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.969338 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.970396 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.976401 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.983360 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.984167 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.990454 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.995973 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204986.999621 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.009499 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.022187 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.022704 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.049033 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.057881 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.062928 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.067917 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.072974 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.077961 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.078233 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.082686 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.087704 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.093337 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.098962 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.104941 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.105011 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.109845 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.116988 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.123605 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.130137 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.131850 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.137686 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.144260 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.151009 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.159082 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.160108 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.167446 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.174919 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.200022 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.220304 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.228465 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.242290 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.254032 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.280586 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.306890 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.333307 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.363264 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.389912 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204987.416824 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.740049 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.744139 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.748740 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.753456 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.758306 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.764533 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.771380 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.778929 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.787143 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.796271 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.807741 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.820722 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.852191 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.912258 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.915831 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.917912 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.920089 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.922315 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.924386 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.926576 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.928978 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.931172 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.933786 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.935920 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.938040 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.940785 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.943675 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.946894 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.959255 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.973702 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204997.988426 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.002548 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.018078 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.031440 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.698161 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.700265 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.702369 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.704507 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.706759 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.708979 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.711166 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.713592 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.715946 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.718372 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.721037 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.723776 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.726533 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.729826 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.733757 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.737227 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.740812 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.745479 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.751362 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.757721 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.778326 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.781204 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.783908 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.786619 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.789192 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.792001 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.794805 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.798120 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.802075 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.806036 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.810042 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.814063 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.817767 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.822069 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.826362 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.830059 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.833540 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.837503 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.842227 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.847518 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.851391 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.856175 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.862148 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.867674 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.874538 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.881633 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.894983 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.908315 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.921640 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.934997 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.950400 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204998.965993 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.111868 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.116141 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.120998 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.125967 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.131110 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.137759 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.145037 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.152927 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.161594 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.171104 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.183032 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.196333 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.228789 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.280744 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.318211 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.322388 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.324488 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.326656 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.328842 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.330892 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.333059 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.335426 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.337596 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.340176 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.342286 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.344371 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.347090 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.350015 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.353262 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.365644 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.379970 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.394543 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.408407 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.424174 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.437741 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.444738 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.448856 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.453502 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.458246 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.463108 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.469416 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.476212 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.483814 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.492101 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.501357 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.513065 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.526314 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.559040 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.619582 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.623882 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.626192 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.628610 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.631049 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.633351 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.635768 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.638409 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.640815 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.643673 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.646043 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.648390 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.651379 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.654519 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.657983 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.670522 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.684915 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.699300 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.713085 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.728844 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727204999.742404 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.107211 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.109340 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.111466 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.113631 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.115907 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.118157 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.120365 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.122819 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.125210 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.127651 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.130239 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.132978 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.135849 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.139248 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.143335 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.146933 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.150652 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.155424 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.161453 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.168004 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.188978 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.191957 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.194741 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.197524 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.200158 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.203034 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.205922 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.209300 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.213309 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.217332 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.221407 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.225479 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.229251 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.233595 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.237898 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.241599 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.245080 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.249049 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.253777 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.259076 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.262963 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.267756 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.273760 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.279333 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.286284 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.293512 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.307018 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.320453 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.333804 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.347398 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.363120 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.378911 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.415799 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.417918 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.420040 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.422197 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.424461 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.426696 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.428901 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.431345 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.433718 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.436160 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.438748 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.441434 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.444162 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.447623 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.451736 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.455373 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.459143 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.464010 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.470072 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.476633 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.497658 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.500616 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.503414 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.506187 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.508801 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.511665 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.514533 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.517900 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.521900 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.525909 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.529956 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.534013 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.537750 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.542104 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.546418 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.550147 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.553683 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.557682 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.562426 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.567755 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.571665 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.576466 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.582519 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.588125 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.595057 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.602239 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.615718 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.629137 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.642475 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.655936 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.671569 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205000.687284 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.829469 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.831938 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.834501 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.837137 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.839943 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.843346 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.847030 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.851043 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.855391 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.861499 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.867430 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.879985 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.906709 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.924087 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.948566 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.949881 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.951161 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.952479 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.953810 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.955225 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.956485 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.957851 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.959195 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.960779 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.962776 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.964336 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.966027 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.967977 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.969848 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.976332 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.983436 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.990657 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205004.997629 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.010679 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.345357 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.346694 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.348057 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.349437 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.350831 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.352215 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.353673 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.355139 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.356637 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.358171 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.359761 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.361391 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.363314 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.365157 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.367143 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.369297 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.371801 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.375124 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.388248 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.389926 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.391636 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.393300 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.395110 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.397118 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.399365 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.401217 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.403059 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.405138 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.407432 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.409592 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.411983 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.414470 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.416433 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.419041 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.421657 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.424236 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.427080 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.429938 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.433172 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.437616 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.444262 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.451158 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.458046 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.464931 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.471820 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.479760 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205005.487717 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.222758 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.225292 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.227935 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.230649 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.233545 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.237052 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.240835 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.244868 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.249222 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.255326 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.261380 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.274346 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.301573 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.319205 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.344973 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.346308 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.347604 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.348926 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.350292 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.351741 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.353034 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.354411 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.355790 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.357423 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.359468 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.361069 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.362799 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.364808 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.366719 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.373344 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.380622 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.388031 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.395175 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.408802 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.558447 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.560923 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.563512 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.566176 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.569010 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.572450 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.576233 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.580262 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.584614 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.590700 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.596674 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.609445 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.636522 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.654308 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.678411 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.679745 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.681036 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.682367 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.683723 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.685172 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.686451 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.687828 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.689201 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.690815 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.692849 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.694445 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.696170 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.698172 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.700074 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.706683 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.713952 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.721353 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.728494 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.741735 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.745700 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.747049 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.748411 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.749812 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.751214 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.752623 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.754083 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.755566 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.757065 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.758616 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.760213 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.761854 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.763771 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.765613 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.767593 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.769757 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.772243 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.775505 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.788384 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.790096 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.791835 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.793751 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.795606 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.797655 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.799956 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.801850 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.803734 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.805848 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.808185 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.810367 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.812798 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.815325 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.817298 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.819947 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.822587 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.825247 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.828140 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.831039 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.834322 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.838873 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.845633 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.852590 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.859546 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.866501 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.873461 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.881460 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205006.889554 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.079679 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.081024 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.082392 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.083782 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.085182 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.086583 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.088047 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.089519 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.091016 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.092561 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.094158 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.095798 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.097731 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.099599 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.101616 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.103806 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.106323 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.109623 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.122391 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.124081 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.125813 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.127493 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.129340 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.131379 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.133673 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.135570 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.137468 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.139582 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.141929 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.144104 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.146540 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.149066 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.151034 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.153667 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.156309 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.158956 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.161842 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.164724 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.168004 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.172531 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.179269 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.186229 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.193183 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.200138 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.207090 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.215047 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.223116 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.747781 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.749478 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.751186 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.752896 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.754845 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.756917 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.759095 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.761382 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.763828 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.767145 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.770481 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.774591 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.781580 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.789347 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.798510 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.812891 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.831562 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.832385 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.833158 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.833975 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.834793 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.835657 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.836415 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.837230 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.838049 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.838955 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.840080 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.841073 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.842172 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.843088 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.844171 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.847768 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.851688 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.855639 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.859579 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205007.866311 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.036771 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.037642 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.038486 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.039327 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.040181 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.041036 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.041931 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.042828 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.043762 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.044700 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.045645 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.046627 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.047773 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.048938 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.050168 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.051470 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.053013 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.054864 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.064136 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.065202 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.066323 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.067652 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.068898 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.070262 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.071697 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.073163 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.074423 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.075695 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.076822 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.078317 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.079816 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.081626 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.083844 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.085536 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.087226 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.089623 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.092032 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.094708 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.097378 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.100881 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.104390 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.107896 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.111409 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.115412 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.119422 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.123941 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205008.128224 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.135497 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.136623 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.137801 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.138990 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.140291 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.141655 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.142702 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.143093 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.144695 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.144721 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.146270 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.146568 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.148400 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.150470 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.152672 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.154913 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.155094 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.157120 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.157562 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.160121 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.160296 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.163272 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.163784 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.167444 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.167463 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.171776 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.172498 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.179319 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.179423 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.187499 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.196863 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.199347 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.200031 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.200667 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.201432 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.202137 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.202880 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.203632 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.204298 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.205089 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.205743 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.206539 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.207422 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.208256 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.208970 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.209844 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.210691 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.211548 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.212850 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.215009 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.217191 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.219344 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.222228 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.231070 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.231904 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.232690 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.233508 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.234344 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.235207 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.235973 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.236788 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.237608 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.238520 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.239660 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.240658 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.241580 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.242696 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.243785 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.247367 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.251276 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.255191 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.259087 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.265843 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.307129 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.307802 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.308465 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.309122 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.309786 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.310564 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.311352 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.312133 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.312969 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.313794 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.314618 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.315488 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.316302 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.317281 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.318272 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.319229 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.320519 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.321606 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.328616 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.329809 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.330728 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.331534 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.332526 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.333546 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.334464 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.335494 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.336325 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.337273 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.338216 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.339361 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.340542 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.341536 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.342506 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.343479 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.344740 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.346001 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.347481 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.348851 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.350222 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.351812 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.353413 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.355276 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.357140 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.358999 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.360860 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.363896 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.366024 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.368142 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.370505 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.437496 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.438356 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.439226 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.440071 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.440946 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.441807 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.442710 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.443618 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.444544 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.445484 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.446440 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.447418 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.448573 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.449732 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.450962 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.452259 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.453801 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.455646 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.464993 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.466075 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.467202 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.468529 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.469779 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.471151 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.472569 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.474058 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.475322 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.476604 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.477740 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.479237 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.480739 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.482566 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.484833 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.486542 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.488250 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.490668 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.492545 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.493112 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.494291 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.495843 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.496061 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.497792 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.498559 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.499768 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.501864 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.502125 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.504101 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.505684 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.506462 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.508981 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.509250 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.512389 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.512802 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.515842 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.516853 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.520000 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.520907 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.525456 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.527166 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.529845 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.535257 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.544515 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.559107 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.579801 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.580631 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.581418 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.582238 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.583066 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.583944 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.584714 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.585535 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.586362 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.587290 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.588446 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.589457 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.590578 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.591516 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.592620 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.596270 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.600256 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.604246 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.608218 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.614921 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.785221 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.786236 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.787268 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.788291 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.789339 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.790371 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.791442 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.792526 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.793626 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.794735 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.795869 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.797027 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.798352 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.799677 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.801086 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.802573 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.804307 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.806314 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.815860 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.817114 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.818431 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.819942 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.821366 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.822914 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.824513 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.826077 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.826249 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.826877 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.827544 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.827791 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.828825 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.828951 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.829874 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.830132 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.830824 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.831717 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.831831 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.832668 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.833351 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.835170 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.837364 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.837733 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.839060 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.839969 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.840752 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.842586 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.843154 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.845543 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.845799 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.848224 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.848691 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.850909 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.854423 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.857056 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.857586 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.858047 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.858152 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.858673 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.859194 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.859719 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.860198 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.860743 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.861215 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.861580 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.861776 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.862326 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.862914 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.863414 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.864075 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.864669 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.865216 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.865323 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.866690 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.868719 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.869212 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.870293 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.871929 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.873217 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.873546 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.877729 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.882056 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.916751 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.917252 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.917732 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.918207 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.918683 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.919242 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.919818 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.920394 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.920964 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.921533 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.922101 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.922687 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.923299 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.923957 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.924678 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.925370 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.931335 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.932028 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.932690 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.933354 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.934096 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.934847 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.935613 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.936400 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.937203 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.938009 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.938640 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.939394 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.940124 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.940855 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.941598 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.942348 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.943115 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.943901 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.944658 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.945861 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.947070 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.948376 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.950171 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.951966 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.953766 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205009.955560 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.164013 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.164694 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.165329 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.166043 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.166730 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.167446 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.168209 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.169100 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.169947 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.171325 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.174555 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.176702 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.178931 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.181738 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.191992 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.192667 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.193451 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.194226 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.194923 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.195945 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.196972 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.198002 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.198796 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.199829 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.200643 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.201452 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.202258 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.203063 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.203864 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.204669 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.205464 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.206250 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.207057 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.207810 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.208559 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.213444 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.214574 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.216101 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.216857 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.217644 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.218521 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.219697 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.220972 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.225078 1395948 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.728336 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.729391 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.730481 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.731590 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.732793 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.734066 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.735382 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.736724 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.738157 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.746356 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.748466 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.751291 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.754283 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.758120 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.762858 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.769327 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.787085 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.787749 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.788383 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.789127 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.789824 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.790559 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.791296 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.791965 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.792745 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.793398 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.794178 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.795046 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.795870 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.796575 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.797424 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.798263 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.800375 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.802516 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.804676 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.806826 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.809694 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.891248 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.892530 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.893876 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.894434 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.895371 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.895544 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.896403 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.896880 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.897258 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.898092 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.898431 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.899064 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.900169 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.900173 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.901136 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.901793 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.902161 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.903175 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.903555 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.904197 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.905256 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.906249 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.907408 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.908561 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.909580 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.911069 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.912483 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.912597 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.914865 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.917996 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.919883 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.921188 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.921462 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.922304 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.923299 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.924482 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.925894 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.926062 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.927013 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.928166 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.929168 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.930323 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.931188 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.931474 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.932807 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.934174 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.935364 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.936526 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.937691 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.938032 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.939154 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.940619 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.942278 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.943839 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.945394 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.947075 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.948717 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.950609 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.952487 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.954397 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.956120 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.956277 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.956798 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.957433 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.958185 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.958879 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.959330 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.959635 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.960375 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.961042 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.961471 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.961840 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.962490 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.963275 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.963604 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.964155 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.964979 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.965686 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.965975 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.966560 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.967404 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.969551 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.971729 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.973928 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.976098 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205010.978994 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.064523 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.065189 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.065845 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.066503 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.067157 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.067939 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.068732 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.069490 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.070328 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.071150 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.071977 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.072843 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.073649 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.074622 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.075599 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.076541 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.077826 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.078923 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.085956 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.087156 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.088077 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.088893 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.089889 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.090909 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.091824 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.092866 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.093698 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.094644 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.095579 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.096723 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.097911 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.098908 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.099886 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.100862 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.102130 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.103392 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.104869 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.106237 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.107608 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.109199 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.110795 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.112672 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.114554 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.116434 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.118313 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.121310 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.123441 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.125575 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.127952 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.415931 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.416734 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.417621 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.418561 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.419595 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.420551 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.421391 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.422363 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.427547 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.429813 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.432469 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.435710 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.438623 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.447105 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.447616 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.448091 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.448625 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.449160 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.449678 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.450168 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.450724 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.451194 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.451751 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.452305 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.452906 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.453428 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.454089 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.454697 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.455304 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.456687 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.458762 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.460347 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.461982 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.463568 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.507329 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.507817 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.508296 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.508763 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.509251 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.509802 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.510374 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.510964 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.511532 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.512092 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.512664 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.513255 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.513865 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.514522 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.515239 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.515936 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.521974 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.522671 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.523329 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.523998 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.524749 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.525500 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.526285 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.527072 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.527887 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.528698 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.529331 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.530077 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.530808 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.531543 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.532291 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.533042 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.533823 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.534610 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.535379 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.536589 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.537799 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.539116 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.540925 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.542732 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.544547 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.546357 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.588511 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.589299 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.590169 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.591085 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.592100 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.593027 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.593818 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.594748 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.599757 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.601961 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.604565 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.607748 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.610616 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.618865 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.619369 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.619841 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.620368 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.620890 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.621402 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.621890 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.622436 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.622895 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.623432 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.623981 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.624578 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.625088 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.625750 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.626346 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.626949 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.628323 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.630400 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.631974 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.633612 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.635199 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.678719 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.679207 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.679685 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.680154 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.680632 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.681187 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.681758 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.682341 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.682907 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.683459 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.684027 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.684614 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.685224 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.685877 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.686598 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.687294 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.693273 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.693975 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.694636 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.695305 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.696057 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.696804 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.697579 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.698362 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.699166 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.699970 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.700600 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.701352 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.702088 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.702816 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.703563 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.704314 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.705088 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.705886 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.706649 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.707853 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.709066 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.710376 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.712182 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.713990 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.715794 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.717602 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.753028 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.753730 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.754390 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.755140 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.755858 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.756607 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.757407 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.758346 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.759246 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.760689 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.764105 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.766511 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.768877 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.771660 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.779699 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.780352 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.781160 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.781967 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.782674 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.783749 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.784819 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.785905 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.786723 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.787772 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.788574 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.789377 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.790179 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.790982 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.791783 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.792581 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.793380 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.794184 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.795000 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.795756 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.796515 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.801480 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.802628 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.804189 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.804962 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.805760 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.806641 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.807797 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.809071 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.812769 1395890 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m 1/48\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1:05:04\u001b[0m 83s/step - loss: 0.0238" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W0000 00:00:1727205011.927083 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.927765 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.928398 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.929121 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.929818 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.930537 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.931317 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.932226 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.933093 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.934482 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.937673 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.939745 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.941881 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.944580 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.952407 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.953040 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.953839 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.954630 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.955327 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.956375 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.957383 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.958396 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.959178 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.960184 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.960968 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.961754 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.962539 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.963322 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.964105 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.964886 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.965670 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.966456 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.967252 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.967996 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.968738 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.973693 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.974834 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.976383 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.977152 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.977940 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.978804 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.979970 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.981251 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727205011.984940 1395909 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 138ms/step - loss: 0.0191" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-24 19:10:18.339210: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-09-24 19:10:18.339281: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "2024-09-24 19:10:18.339411: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 793/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m91s\u001b[0m 164ms/step - loss: 0.0190 - val_loss: 0.0237 - learning_rate: 0.0010\n", + "Epoch 2/251\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2024-09-20 12:39:17.265076: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "2024-09-24 19:10:19.613316: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 794/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 177ms/step - loss: 0.0159" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 132ms/step - loss: 0.0094" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2024-09-20 12:40:21.245677: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "2024-09-24 19:10:26.284018: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 198ms/step - loss: 0.0159 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 795/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 191ms/step - loss: 0.0094 - val_loss: 0.0174 - learning_rate: 0.0010\n", + "Epoch 3/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 146ms/step - loss: 0.0083 - val_loss: 0.0178 - learning_rate: 0.0010\n", + "Epoch 4/251\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2024-09-20 12:41:24.775160: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "2024-09-24 19:10:36.337298: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 796/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0159" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0078 - val_loss: 0.0206 - learning_rate: 0.0010\n", + "Epoch 5/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 147ms/step - loss: 0.0074 - val_loss: 0.0203 - learning_rate: 0.0010\n", + "Epoch 6/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 132ms/step - loss: 0.0071" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2024-09-20 12:42:31.329334: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "2024-09-24 19:11:00.005967: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 193ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 797/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 152ms/step - loss: 0.0071 - val_loss: 0.0180 - learning_rate: 0.0010\n", + "Epoch 7/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 148ms/step - loss: 0.0069 - val_loss: 0.0098 - learning_rate: 0.0010\n", + "Epoch 8/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 146ms/step - loss: 0.0068 - val_loss: 0.0099 - learning_rate: 0.0010\n", + "Epoch 9/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 147ms/step - loss: 0.0066 - val_loss: 0.0332 - learning_rate: 0.0010\n", + "Epoch 10/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 207ms/step - loss: 0.0066 - val_loss: 0.0120 - learning_rate: 0.0010\n", + "Epoch 11/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 148ms/step - loss: 0.0067 - val_loss: 0.0173 - learning_rate: 0.0010\n", + "Epoch 12/251\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2024-09-20 12:43:35.427683: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "2024-09-24 19:11:45.623663: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 798/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 147ms/step - loss: 0.0065 - val_loss: 0.0202 - learning_rate: 0.0010\n", + "Epoch 13/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 206ms/step - loss: 0.0064 - val_loss: 0.0192 - learning_rate: 0.0010\n", + "Epoch 14/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 149ms/step - loss: 0.0063 - val_loss: 0.0163 - learning_rate: 0.0010\n", + "Epoch 15/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 155ms/step - loss: 0.0063 - val_loss: 0.0158 - learning_rate: 0.0010\n", + "Epoch 16/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0062 - val_loss: 0.0090 - learning_rate: 0.0010\n", + "Epoch 17/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 203ms/step - loss: 0.0061 - val_loss: 0.0152 - learning_rate: 0.0010\n", + "Epoch 18/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 221ms/step - loss: 0.0061 - val_loss: 0.0157 - learning_rate: 0.0010\n", + "Epoch 19/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 151ms/step - loss: 0.0060 - val_loss: 0.0235 - learning_rate: 0.0010\n", + "Epoch 20/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 152ms/step - loss: 0.0060 - val_loss: 0.0178 - learning_rate: 0.0010\n", + "Epoch 21/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 201ms/step - loss: 0.0060 - val_loss: 0.0528 - learning_rate: 0.0010\n", + "Epoch 22/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step - loss: 0.0063" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2024-09-20 12:44:40.461677: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "2024-09-24 19:13:28.950884: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", + "\t [[RemoteCall]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 199ms/step - loss: 0.0063 - val_loss: 0.0219 - learning_rate: 0.0010\n", + "Epoch 23/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 167ms/step - loss: 0.0061 - val_loss: 0.0140 - learning_rate: 0.0010\n", + "Epoch 24/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 171ms/step - loss: 0.0060 - val_loss: 0.0387 - learning_rate: 0.0010\n", + "Epoch 25/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 160ms/step - loss: 0.0060 - val_loss: 0.0153 - learning_rate: 0.0010\n", + "Epoch 26/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 162ms/step - loss: 0.0059\n", + "Epoch 26: ReduceLROnPlateau reducing learning rate to 0.000800000037997961.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 237ms/step - loss: 0.0059 - val_loss: 0.0211 - learning_rate: 0.0010\n", + "Epoch 27/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 226ms/step - loss: 0.0058 - val_loss: 0.0185 - learning_rate: 8.0000e-04\n", + "Epoch 28/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 210ms/step - loss: 0.0058 - val_loss: 0.0163 - learning_rate: 8.0000e-04\n", + "Epoch 29/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0058 - val_loss: 0.0094 - learning_rate: 8.0000e-04\n", + "Epoch 30/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 148ms/step - loss: 0.0057 - val_loss: 0.0159 - learning_rate: 8.0000e-04\n", + "Epoch 31/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0057 - val_loss: 0.0061 - learning_rate: 8.0000e-04\n", + "Epoch 32/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 191ms/step - loss: 0.0057 - val_loss: 0.0173 - learning_rate: 8.0000e-04\n", + "Epoch 33/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0057 - val_loss: 0.0143 - learning_rate: 8.0000e-04\n", + "Epoch 34/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0056 - val_loss: 0.0143 - learning_rate: 8.0000e-04\n", + "Epoch 35/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0057 - val_loss: 0.0186 - learning_rate: 8.0000e-04\n", + "Epoch 36/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 157ms/step - loss: 0.0056 - val_loss: 0.0175 - learning_rate: 8.0000e-04\n", + "Epoch 37/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 211ms/step - loss: 0.0056 - val_loss: 0.0209 - learning_rate: 8.0000e-04\n", + "Epoch 38/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0056 - val_loss: 0.0176 - learning_rate: 8.0000e-04\n", + "Epoch 39/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 167ms/step - loss: 0.0056 - val_loss: 0.0184 - learning_rate: 8.0000e-04\n", + "Epoch 40/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 207ms/step - loss: 0.0055 - val_loss: 0.0234 - learning_rate: 8.0000e-04\n", + "Epoch 41/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step - loss: 0.0055\n", + "Epoch 41: ReduceLROnPlateau reducing learning rate to 0.0006400000303983689.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0055 - val_loss: 0.0149 - learning_rate: 8.0000e-04\n", + "Epoch 42/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0054 - val_loss: 0.0106 - learning_rate: 6.4000e-04\n", + "Epoch 43/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 191ms/step - loss: 0.0054 - val_loss: 0.0161 - learning_rate: 6.4000e-04\n", + "Epoch 44/251\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-24 19:16:43.539021: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 799/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:45:45.404978: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0054 - val_loss: 0.0140 - learning_rate: 6.4000e-04\n", + "Epoch 45/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0054 - val_loss: 0.0199 - learning_rate: 6.4000e-04\n", + "Epoch 46/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 194ms/step - loss: 0.0053 - val_loss: 0.0156 - learning_rate: 6.4000e-04\n", + "Epoch 47/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 207ms/step - loss: 0.0053 - val_loss: 0.0182 - learning_rate: 6.4000e-04\n", + "Epoch 48/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0054 - val_loss: 0.0155 - learning_rate: 6.4000e-04\n", + "Epoch 49/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 160ms/step - loss: 0.0053 - val_loss: 0.0219 - learning_rate: 6.4000e-04\n", + "Epoch 50/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0053 - val_loss: 0.0287 - learning_rate: 6.4000e-04\n", + "Epoch 51/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0052\n", + "Epoch 51: ReduceLROnPlateau reducing learning rate to 0.0005120000336319208.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 162ms/step - loss: 0.0052 - val_loss: 0.0252 - learning_rate: 6.4000e-04\n", + "Epoch 52/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 150ms/step - loss: 0.0052 - val_loss: 0.0129 - learning_rate: 5.1200e-04\n", + "Epoch 53/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0052 - val_loss: 0.0060 - learning_rate: 5.1200e-04\n", + "Epoch 54/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0052 - val_loss: 0.0215 - learning_rate: 5.1200e-04\n", + "Epoch 55/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 154ms/step - loss: 0.0051 - val_loss: 0.0241 - learning_rate: 5.1200e-04\n", + "Epoch 56/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 152ms/step - loss: 0.0052 - val_loss: 0.0172 - learning_rate: 5.1200e-04\n", + "Epoch 57/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 213ms/step - loss: 0.0051 - val_loss: 0.0147 - learning_rate: 5.1200e-04\n", + "Epoch 58/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0051 - val_loss: 0.0118 - learning_rate: 5.1200e-04\n", + "Epoch 59/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0051 - val_loss: 0.0139 - learning_rate: 5.1200e-04\n", + "Epoch 60/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 197ms/step - loss: 0.0051 - val_loss: 0.0190 - learning_rate: 5.1200e-04\n", + "Epoch 61/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0050 - val_loss: 0.0245 - learning_rate: 5.1200e-04\n", + "Epoch 62/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0050 - val_loss: 0.0179 - learning_rate: 5.1200e-04\n", + "Epoch 63/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0051\n", + "Epoch 63: ReduceLROnPlateau reducing learning rate to 0.00040960004553198815.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 191ms/step - loss: 0.0051 - val_loss: 0.0190 - learning_rate: 5.1200e-04\n", + "Epoch 64/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0050 - val_loss: 0.0071 - learning_rate: 4.0960e-04\n", + "Epoch 65/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 152ms/step - loss: 0.0050 - val_loss: 0.0170 - learning_rate: 4.0960e-04\n", + "Epoch 66/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 198ms/step - loss: 0.0050 - val_loss: 0.0195 - learning_rate: 4.0960e-04\n", + "Epoch 67/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0050 - val_loss: 0.0109 - learning_rate: 4.0960e-04\n", + "Epoch 68/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0049 - val_loss: 0.0126 - learning_rate: 4.0960e-04\n", + "Epoch 69/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 203ms/step - loss: 0.0048 - val_loss: 0.0186 - learning_rate: 4.0960e-04\n", + "Epoch 70/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 211ms/step - loss: 0.0048 - val_loss: 0.0190 - learning_rate: 4.0960e-04\n", + "Epoch 71/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0048 - val_loss: 0.0266 - learning_rate: 4.0960e-04\n", + "Epoch 72/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0049 - val_loss: 0.0207 - learning_rate: 4.0960e-04\n", + "Epoch 73/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step - loss: 0.0048\n", + "Epoch 73: ReduceLROnPlateau reducing learning rate to 0.00032768002711236477.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 152ms/step - loss: 0.0048 - val_loss: 0.0197 - learning_rate: 4.0960e-04\n", + "Epoch 74/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0048 - val_loss: 0.0215 - learning_rate: 3.2768e-04\n", + "Epoch 75/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 149ms/step - loss: 0.0048 - val_loss: 0.0200 - learning_rate: 3.2768e-04\n", + "Epoch 76/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 189ms/step - loss: 0.0047 - val_loss: 0.0127 - learning_rate: 3.2768e-04\n", + "Epoch 77/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0047 - val_loss: 0.0231 - learning_rate: 3.2768e-04\n", + "Epoch 78/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 164ms/step - loss: 0.0047 - val_loss: 0.0200 - learning_rate: 3.2768e-04\n", + "Epoch 79/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 207ms/step - loss: 0.0047 - val_loss: 0.0307 - learning_rate: 3.2768e-04\n", + "Epoch 80/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 211ms/step - loss: 0.0046 - val_loss: 0.0194 - learning_rate: 3.2768e-04\n", + "Epoch 81/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 208ms/step - loss: 0.0046 - val_loss: 0.0092 - learning_rate: 3.2768e-04\n", + "Epoch 82/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0046 - val_loss: 0.0137 - learning_rate: 3.2768e-04\n", + "Epoch 83/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step - loss: 0.0046\n", + "Epoch 83: ReduceLROnPlateau reducing learning rate to 0.0002621440216898918.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0046 - val_loss: 0.0172 - learning_rate: 3.2768e-04\n", + "Epoch 84/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 187ms/step - loss: 0.0045 - val_loss: 0.0142 - learning_rate: 2.6214e-04\n", + "Epoch 85/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 205ms/step - loss: 0.0045 - val_loss: 0.0168 - learning_rate: 2.6214e-04\n", + "Epoch 86/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0044" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-24 19:23:05.266275: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "Epoch 799: ReduceLROnPlateau reducing learning rate to 2.427495132906188e-06.\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 192ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.6972e-06\n", - "Epoch 800/800\n", - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - loss: 0.0158" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 12:46:49.416134: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.\n" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0045 - val_loss: 0.0186 - learning_rate: 2.6214e-04\n", + "Epoch 87/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 152ms/step - loss: 0.0045 - val_loss: 0.0148 - learning_rate: 2.6214e-04\n", + "Epoch 88/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0045 - val_loss: 0.0173 - learning_rate: 2.6214e-04\n", + "Epoch 89/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 148ms/step - loss: 0.0044 - val_loss: 0.0173 - learning_rate: 2.6214e-04\n", + "Epoch 90/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 204ms/step - loss: 0.0044 - val_loss: 0.0136 - learning_rate: 2.6214e-04\n", + "Epoch 91/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 148ms/step - loss: 0.0044 - val_loss: 0.0089 - learning_rate: 2.6214e-04\n", + "Epoch 92/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0043 - val_loss: 0.0190 - learning_rate: 2.6214e-04\n", + "Epoch 93/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step - loss: 0.0043\n", + "Epoch 93: ReduceLROnPlateau reducing learning rate to 0.00020971521735191345.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 196ms/step - loss: 0.0043 - val_loss: 0.0245 - learning_rate: 2.6214e-04\n", + "Epoch 94/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 211ms/step - loss: 0.0043 - val_loss: 0.0210 - learning_rate: 2.0972e-04\n", + "Epoch 95/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0043 - val_loss: 0.0153 - learning_rate: 2.0972e-04\n", + "Epoch 96/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0042 - val_loss: 0.0224 - learning_rate: 2.0972e-04\n", + "Epoch 97/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 201ms/step - loss: 0.0042 - val_loss: 0.0193 - learning_rate: 2.0972e-04\n", + "Epoch 98/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 153ms/step - loss: 0.0042 - val_loss: 0.0123 - learning_rate: 2.0972e-04\n", + "Epoch 99/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0042 - val_loss: 0.0308 - learning_rate: 2.0972e-04\n", + "Epoch 100/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 166ms/step - loss: 0.0042 - val_loss: 0.0151 - learning_rate: 2.0972e-04\n", + "Epoch 101/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 150ms/step - loss: 0.0042 - val_loss: 0.0142 - learning_rate: 2.0972e-04\n", + "Epoch 102/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 199ms/step - loss: 0.0041 - val_loss: 0.0208 - learning_rate: 2.0972e-04\n", + "Epoch 103/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0041\n", + "Epoch 103: ReduceLROnPlateau reducing learning rate to 0.00016777217388153076.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0041 - val_loss: 0.0234 - learning_rate: 2.0972e-04\n", + "Epoch 104/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0041 - val_loss: 0.0194 - learning_rate: 1.6777e-04\n", + "Epoch 105/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 161ms/step - loss: 0.0040 - val_loss: 0.0114 - learning_rate: 1.6777e-04\n", + "Epoch 106/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 150ms/step - loss: 0.0041 - val_loss: 0.0184 - learning_rate: 1.6777e-04\n", + "Epoch 107/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 198ms/step - loss: 0.0040 - val_loss: 0.0213 - learning_rate: 1.6777e-04\n", + "Epoch 108/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 225ms/step - loss: 0.0040 - val_loss: 0.0170 - learning_rate: 1.6777e-04\n", + "Epoch 109/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 217ms/step - loss: 0.0040 - val_loss: 0.0132 - learning_rate: 1.6777e-04\n", + "Epoch 110/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0040 - val_loss: 0.0084 - learning_rate: 1.6777e-04\n", + "Epoch 111/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 160ms/step - loss: 0.0039 - val_loss: 0.0129 - learning_rate: 1.6777e-04\n", + "Epoch 112/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 149ms/step - loss: 0.0039 - val_loss: 0.0173 - learning_rate: 1.6777e-04\n", + "Epoch 113/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 157ms/step - loss: 0.0039 - val_loss: 0.0058 - learning_rate: 1.6777e-04\n", + "Epoch 114/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0039 - val_loss: 0.0061 - learning_rate: 1.6777e-04\n", + "Epoch 115/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 185ms/step - loss: 0.0038 - val_loss: 0.0088 - learning_rate: 1.6777e-04\n", + "Epoch 116/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 157ms/step - loss: 0.0038 - val_loss: 0.0147 - learning_rate: 1.6777e-04\n", + "Epoch 117/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 151ms/step - loss: 0.0038 - val_loss: 0.0095 - learning_rate: 1.6777e-04\n", + "Epoch 118/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 187ms/step - loss: 0.0038 - val_loss: 0.0157 - learning_rate: 1.6777e-04\n", + "Epoch 119/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 174ms/step - loss: 0.0038 - val_loss: 0.0103 - learning_rate: 1.6777e-04\n", + "Epoch 120/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 150ms/step - loss: 0.0038 - val_loss: 0.0150 - learning_rate: 1.6777e-04\n", + "Epoch 121/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 152ms/step - loss: 0.0038 - val_loss: 0.0313 - learning_rate: 1.6777e-04\n", + "Epoch 122/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 188ms/step - loss: 0.0038 - val_loss: 0.0328 - learning_rate: 1.6777e-04\n", + "Epoch 123/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step - loss: 0.0037\n", + "Epoch 123: ReduceLROnPlateau reducing learning rate to 0.00013421773910522462.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 204ms/step - loss: 0.0037 - val_loss: 0.0069 - learning_rate: 1.6777e-04\n", + "Epoch 124/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0037 - val_loss: 0.0073 - learning_rate: 1.3422e-04\n", + "Epoch 125/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0037 - val_loss: 0.0058 - learning_rate: 1.3422e-04\n", + "Epoch 126/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 186ms/step - loss: 0.0037 - val_loss: 0.0088 - learning_rate: 1.3422e-04\n", + "Epoch 127/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0037 - val_loss: 0.0071 - learning_rate: 1.3422e-04\n", + "Epoch 128/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0036 - val_loss: 0.0081 - learning_rate: 1.3422e-04\n", + "Epoch 129/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 191ms/step - loss: 0.0036 - val_loss: 0.0135 - learning_rate: 1.3422e-04\n", + "Epoch 130/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0036 - val_loss: 0.0140 - learning_rate: 1.3422e-04\n", + "Epoch 131/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 148ms/step - loss: 0.0035 - val_loss: 0.0122 - learning_rate: 1.3422e-04\n", + "Epoch 132/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 200ms/step - loss: 0.0036 - val_loss: 0.0163 - learning_rate: 1.3422e-04\n", + "Epoch 133/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step - loss: 0.0035\n", + "Epoch 133: ReduceLROnPlateau reducing learning rate to 0.00010737419361248613.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0036 - val_loss: 0.0144 - learning_rate: 1.3422e-04\n", + "Epoch 134/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0035 - val_loss: 0.0063 - learning_rate: 1.0737e-04\n", + "Epoch 135/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 202ms/step - loss: 0.0035 - val_loss: 0.0057 - learning_rate: 1.0737e-04\n", + "Epoch 136/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 204ms/step - loss: 0.0035 - val_loss: 0.0134 - learning_rate: 1.0737e-04\n", + "Epoch 137/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0035 - val_loss: 0.0080 - learning_rate: 1.0737e-04\n", + "Epoch 138/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0035 - val_loss: 0.0085 - learning_rate: 1.0737e-04\n", + "Epoch 139/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 202ms/step - loss: 0.0034 - val_loss: 0.0206 - learning_rate: 1.0737e-04\n", + "Epoch 140/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0035 - val_loss: 0.0121 - learning_rate: 1.0737e-04\n", + "Epoch 141/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0034 - val_loss: 0.0182 - learning_rate: 1.0737e-04\n", + "Epoch 142/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 199ms/step - loss: 0.0034 - val_loss: 0.0087 - learning_rate: 1.0737e-04\n", + "Epoch 143/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 154ms/step - loss: 0.0034 - val_loss: 0.0111 - learning_rate: 1.0737e-04\n", + "Epoch 144/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 149ms/step - loss: 0.0034 - val_loss: 0.0169 - learning_rate: 1.0737e-04\n", + "Epoch 145/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0033\n", + "Epoch 145: ReduceLROnPlateau reducing learning rate to 8.589935605414213e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 198ms/step - loss: 0.0034 - val_loss: 0.0185 - learning_rate: 1.0737e-04\n", + "Epoch 146/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0034 - val_loss: 0.0139 - learning_rate: 8.5899e-05\n", + "Epoch 147/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0033 - val_loss: 0.0061 - learning_rate: 8.5899e-05\n", + "Epoch 148/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 203ms/step - loss: 0.0033 - val_loss: 0.0058 - learning_rate: 8.5899e-05\n", + "Epoch 149/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0033 - val_loss: 0.0060 - learning_rate: 8.5899e-05\n", + "Epoch 150/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0033 - val_loss: 0.0085 - learning_rate: 8.5899e-05\n", + "Epoch 151/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 191ms/step - loss: 0.0033 - val_loss: 0.0063 - learning_rate: 8.5899e-05\n", + "Epoch 152/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0033 - val_loss: 0.0077 - learning_rate: 8.5899e-05\n", + "Epoch 153/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 151ms/step - loss: 0.0033 - val_loss: 0.0070 - learning_rate: 8.5899e-05\n", + "Epoch 154/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 193ms/step - loss: 0.0032 - val_loss: 0.0123 - learning_rate: 8.5899e-05\n", + "Epoch 155/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step - loss: 0.0032\n", + "Epoch 155: ReduceLROnPlateau reducing learning rate to 6.871948717162013e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 149ms/step - loss: 0.0032 - val_loss: 0.0060 - learning_rate: 8.5899e-05\n", + "Epoch 156/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 152ms/step - loss: 0.0032 - val_loss: 0.0066 - learning_rate: 6.8719e-05\n", + "Epoch 157/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0032 - val_loss: 0.0060 - learning_rate: 6.8719e-05\n", + "Epoch 158/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 185ms/step - loss: 0.0032 - val_loss: 0.0059 - learning_rate: 6.8719e-05\n", + "Epoch 159/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0032 - val_loss: 0.0057 - learning_rate: 6.8719e-05\n", + "Epoch 160/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0032 - val_loss: 0.0061 - learning_rate: 6.8719e-05\n", + "Epoch 161/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 186ms/step - loss: 0.0031 - val_loss: 0.0058 - learning_rate: 6.8719e-05\n", + "Epoch 162/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0032 - val_loss: 0.0068 - learning_rate: 6.8719e-05\n", + "Epoch 163/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0031 - val_loss: 0.0064 - learning_rate: 6.8719e-05\n", + "Epoch 164/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 186ms/step - loss: 0.0032 - val_loss: 0.0124 - learning_rate: 6.8719e-05\n", + "Epoch 165/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0032\n", + "Epoch 165: ReduceLROnPlateau reducing learning rate to 5.497558740898967e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0032 - val_loss: 0.0062 - learning_rate: 6.8719e-05\n", + "Epoch 166/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0031 - val_loss: 0.0058 - learning_rate: 5.4976e-05\n", + "Epoch 167/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 186ms/step - loss: 0.0031 - val_loss: 0.0059 - learning_rate: 5.4976e-05\n", + "Epoch 168/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0031 - val_loss: 0.0062 - learning_rate: 5.4976e-05\n", + "Epoch 169/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 165ms/step - loss: 0.0031 - val_loss: 0.0060 - learning_rate: 5.4976e-05\n", + "Epoch 170/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 201ms/step - loss: 0.0031 - val_loss: 0.0060 - learning_rate: 5.4976e-05\n", + "Epoch 171/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 153ms/step - loss: 0.0031 - val_loss: 0.0070 - learning_rate: 5.4976e-05\n", + "Epoch 172/251\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-24 19:35:50.267301: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", + "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m320/320\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 199ms/step - loss: 0.0158 - val_loss: 0.0102 - learning_rate: 2.4275e-06\n" + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0030 - val_loss: 0.0066 - learning_rate: 5.4976e-05\n", + "Epoch 173/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 199ms/step - loss: 0.0030 - val_loss: 0.0057 - learning_rate: 5.4976e-05\n", + "Epoch 174/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 213ms/step - loss: 0.0030 - val_loss: 0.0061 - learning_rate: 5.4976e-05\n", + "Epoch 175/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0030\n", + "Epoch 175: ReduceLROnPlateau reducing learning rate to 4.398046876303852e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0030 - val_loss: 0.0060 - learning_rate: 5.4976e-05\n", + "Epoch 176/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0030 - val_loss: 0.0062 - learning_rate: 4.3980e-05\n", + "Epoch 177/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 190ms/step - loss: 0.0030 - val_loss: 0.0064 - learning_rate: 4.3980e-05\n", + "Epoch 178/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0030 - val_loss: 0.0072 - learning_rate: 4.3980e-05\n", + "Epoch 179/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 169ms/step - loss: 0.0030 - val_loss: 0.0076 - learning_rate: 4.3980e-05\n", + "Epoch 180/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0030 - val_loss: 0.0076 - learning_rate: 4.3980e-05\n", + "Epoch 181/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0030 - val_loss: 0.0059 - learning_rate: 4.3980e-05\n", + "Epoch 182/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 197ms/step - loss: 0.0030 - val_loss: 0.0059 - learning_rate: 4.3980e-05\n", + "Epoch 183/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0030 - val_loss: 0.0062 - learning_rate: 4.3980e-05\n", + "Epoch 184/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 150ms/step - loss: 0.0030 - val_loss: 0.0059 - learning_rate: 4.3980e-05\n", + "Epoch 185/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0030\n", + "Epoch 185: ReduceLROnPlateau reducing learning rate to 3.518437442835421e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 205ms/step - loss: 0.0030 - val_loss: 0.0059 - learning_rate: 4.3980e-05\n", + "Epoch 186/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0030 - val_loss: 0.0060 - learning_rate: 3.5184e-05\n", + "Epoch 187/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0030 - val_loss: 0.0059 - learning_rate: 3.5184e-05\n", + "Epoch 188/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 196ms/step - loss: 0.0030 - val_loss: 0.0059 - learning_rate: 3.5184e-05\n", + "Epoch 189/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0029 - val_loss: 0.0061 - learning_rate: 3.5184e-05\n", + "Epoch 190/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0029 - val_loss: 0.0060 - learning_rate: 3.5184e-05\n", + "Epoch 191/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 201ms/step - loss: 0.0029 - val_loss: 0.0063 - learning_rate: 3.5184e-05\n", + "Epoch 192/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 204ms/step - loss: 0.0030 - val_loss: 0.0066 - learning_rate: 3.5184e-05\n", + "Epoch 193/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 191ms/step - loss: 0.0029 - val_loss: 0.0059 - learning_rate: 3.5184e-05\n", + "Epoch 194/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0029 - val_loss: 0.0064 - learning_rate: 3.5184e-05\n", + "Epoch 195/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0029\n", + "Epoch 195: ReduceLROnPlateau reducing learning rate to 2.8147498960606756e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 176ms/step - loss: 0.0030 - val_loss: 0.0065 - learning_rate: 3.5184e-05\n", + "Epoch 196/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0029 - val_loss: 0.0060 - learning_rate: 2.8147e-05\n", + "Epoch 197/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0029 - val_loss: 0.0062 - learning_rate: 2.8147e-05\n", + "Epoch 198/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 188ms/step - loss: 0.0029 - val_loss: 0.0062 - learning_rate: 2.8147e-05\n", + "Epoch 199/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 207ms/step - loss: 0.0029 - val_loss: 0.0060 - learning_rate: 2.8147e-05\n", + "Epoch 200/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0029 - val_loss: 0.0059 - learning_rate: 2.8147e-05\n", + "Epoch 201/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0029 - val_loss: 0.0060 - learning_rate: 2.8147e-05\n", + "Epoch 202/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 187ms/step - loss: 0.0029 - val_loss: 0.0060 - learning_rate: 2.8147e-05\n", + "Epoch 203/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 209ms/step - loss: 0.0029 - val_loss: 0.0061 - learning_rate: 2.8147e-05\n", + "Epoch 204/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0029 - val_loss: 0.0061 - learning_rate: 2.8147e-05\n", + "Epoch 205/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0029\n", + "Epoch 205: ReduceLROnPlateau reducing learning rate to 2.25179988774471e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0029 - val_loss: 0.0058 - learning_rate: 2.8147e-05\n", + "Epoch 206/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 2.2518e-05\n", + "Epoch 207/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0029 - val_loss: 0.0058 - learning_rate: 2.2518e-05\n", + "Epoch 208/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0061 - learning_rate: 2.2518e-05\n", + "Epoch 209/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 188ms/step - loss: 0.0029 - val_loss: 0.0058 - learning_rate: 2.2518e-05\n", + "Epoch 210/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0029 - val_loss: 0.0057 - learning_rate: 2.2518e-05\n", + "Epoch 211/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 149ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 2.2518e-05\n", + "Epoch 212/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 179ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 2.2518e-05\n", + "Epoch 213/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 149ms/step - loss: 0.0028 - val_loss: 0.0062 - learning_rate: 2.2518e-05\n", + "Epoch 214/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 197ms/step - loss: 0.0028 - val_loss: 0.0062 - learning_rate: 2.2518e-05\n", + "Epoch 215/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0028\n", + "Epoch 215: ReduceLROnPlateau reducing learning rate to 1.8014399392995985e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 2.2518e-05\n", + "Epoch 216/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.8014e-05\n", + "Epoch 217/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 200ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.8014e-05\n", + "Epoch 218/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 208ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.8014e-05\n", + "Epoch 219/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.8014e-05\n", + "Epoch 220/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 1.8014e-05\n", + "Epoch 221/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 152ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.8014e-05\n", + "Epoch 222/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 158ms/step - loss: 0.0028 - val_loss: 0.0057 - learning_rate: 1.8014e-05\n", + "Epoch 223/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 151ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 1.8014e-05\n", + "Epoch 224/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 1.8014e-05\n", + "Epoch 225/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 136ms/step - loss: 0.0028\n", + "Epoch 225: ReduceLROnPlateau reducing learning rate to 1.4411519805435093e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 190ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 1.8014e-05\n", + "Epoch 226/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 1.4412e-05\n", + "Epoch 227/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 152ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 1.4412e-05\n", + "Epoch 228/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 201ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.4412e-05\n", + "Epoch 229/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0028 - val_loss: 0.0061 - learning_rate: 1.4412e-05\n", + "Epoch 230/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 1.4412e-05\n", + "Epoch 231/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 202ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.4412e-05\n", + "Epoch 232/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.4412e-05\n", + "Epoch 233/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 151ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.4412e-05\n", + "Epoch 234/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 149ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 1.4412e-05\n", + "Epoch 235/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 135ms/step - loss: 0.0028\n", + "Epoch 235: ReduceLROnPlateau reducing learning rate to 1.1529216135386379e-05.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 163ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 1.4412e-05\n", + "Epoch 236/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0061 - learning_rate: 1.1529e-05\n", + "Epoch 237/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.1529e-05\n", + "Epoch 238/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 189ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.1529e-05\n", + "Epoch 239/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 208ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 1.1529e-05\n", + "Epoch 240/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 1.1529e-05\n", + "Epoch 241/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0027 - val_loss: 0.0060 - learning_rate: 1.1529e-05\n", + "Epoch 242/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 191ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 1.1529e-05\n", + "Epoch 243/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 1.1529e-05\n", + "Epoch 244/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 150ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 1.1529e-05\n", + "Epoch 245/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 137ms/step - loss: 0.0028\n", + "Epoch 245: ReduceLROnPlateau reducing learning rate to 9.223372762789951e-06.\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 188ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 1.1529e-05\n", + "Epoch 246/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 169ms/step - loss: 0.0028 - val_loss: 0.0060 - learning_rate: 9.2234e-06\n", + "Epoch 247/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 149ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 9.2234e-06\n", + "Epoch 248/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 152ms/step - loss: 0.0028 - val_loss: 0.0059 - learning_rate: 9.2234e-06\n", + "Epoch 249/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 149ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 9.2234e-06\n", + "Epoch 250/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 203ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 9.2234e-06\n", + "Epoch 251/251\n", + "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 207ms/step - loss: 0.0028 - val_loss: 0.0058 - learning_rate: 9.2234e-06\n" ] } ], "source": [ "\n", - "# Train the model\n", + "# Train the model with the custom callback\n", "history = model_builder.train_model(\n", " train_dataset, \n", " val_dataset, \n", - " epochs=800,\n", - " callbacks_list=[update_epoch_callback,lr_scheduler]\n", + " epochs=251,\n", + " callbacks_list=[lr_scheduler]\n", ")\n" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # Initialize the ModelBuilder within the strategy scope\n", + "# with strategy.scope():\n", + "# # Instantiate the model builder\n", + "# model_builder = ModelBuilder()\n", + "\n", + "# # Build the model\n", + "# model_builder.build_model()\n", + "\n", + "# # Display the model architecture\n", + "# model_builder.model.summary()\n", + "\n", + "# # Compile the model\n", + "# # model_builder.compile_model(loss_function=dynamic_huber_loss)\n", + "# model_builder.compile_model(loss_function=tf.keras.losses.MeanSquaredError())\n", + "# # If using a custom loss function, replace the above line with:\n", + "# # model_builder.compile_model(loss_function=custom_loss(exponent=2))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAJOCAYAAAA+iJoEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAADy/klEQVR4nOydd7gTVf7G3yT35vZCufTeixRFUECKiiIqiq6uiw0sawPLKq7u6iqiP3tdFruCDcWCuqugoAuroiIdFaT3IvVye0vO74/JmTlzMpNMkkkyuff7eR6e9JmTZLjz5v02F2OMgSAIgiAIgkhZ3MleAEEQBEEQBBEbJOgIgiAIgiBSHBJ0BEEQBEEQKQ4JOoIgCIIgiBSHBB1BEARBEESKQ4KOIAiCIAgixSFBRxAEQRAEkeKQoCMIgiAIgkhxSNARBEEQBEGkOCToCKIBMnHiRHTo0CGq106dOhUul8veBTmM7du3w+VyYdasWQnft8vlwtSpU9Xbs2bNgsvlwvbt28O+tkOHDpg4caKt64nlWCEIInGQoCMIB+FyuSz9W7x4cbKX2uC55ZZb4HK5sHnzZtPn3HPPPXC5XFi7dm0CVxY5e/fuxdSpU7F69epkL0WFi+onn3wy2UshiJQgLdkLIAhC46233tLdfvPNN7Fw4cKg+3v27BnTfl555RX4/f6oXnvvvffi7rvvjmn/9YHLLrsM06dPx+zZs3HfffcZPufdd99Fnz590Ldv36j3c8UVV+BPf/oTMjIyot5GOPbu3YsHHngAHTp0QP/+/XWPxXKsEASROEjQEYSDuPzyy3W3f/zxRyxcuDDofpmKigpkZ2db3k96enpU6wOAtLQ0pKXRn46TTjoJXbp0wbvvvmso6H744Qds27YNjz76aEz78Xg88Hg8MW0jFmI5VgiCSBwUciWIFGPkyJE47rjjsGLFCgwfPhzZ2dn4+9//DgD49NNPcc4556BVq1bIyMhA586d8eCDD8Ln8+m2IedFieGtl19+GZ07d0ZGRgYGDhyIZcuW6V5rlEPncrkwefJkfPLJJzjuuOOQkZGB3r1744svvgha/+LFi3HiiSciMzMTnTt3xksvvWQ5L+/bb7/FxRdfjHbt2iEjIwNt27bFX/7yF1RWVga9v9zcXOzZswfjxo1Dbm4uioqKMGXKlKDPori4GBMnTkRBQQEKCwsxYcIEFBcXh10LoLh0v/32G1auXBn02OzZs+FyuTB+/HjU1NTgvvvuw4ABA1BQUICcnBwMGzYMixYtCrsPoxw6xhgeeughtGnTBtnZ2Tj11FPx66+/Br32yJEjmDJlCvr06YPc3Fzk5+djzJgxWLNmjfqcxYsXY+DAgQCAq666Sg3r8/xBoxy68vJy3HHHHWjbti0yMjLQvXt3PPnkk2CM6Z4XyXERLQcOHMA111yD5s2bIzMzE/369cMbb7wR9Lz33nsPAwYMQF5eHvLz89GnTx8899xz6uO1tbV44IEH0LVrV2RmZqJJkyY45ZRTsHDhQtvWShDxhH5mE0QKcvjwYYwZMwZ/+tOfcPnll6N58+YAlJN/bm4ubr/9duTm5uK///0v7rvvPpSUlOCJJ54Iu93Zs2ejtLQU119/PVwuFx5//HFceOGF2Lp1a1in5rvvvsPcuXNx0003IS8vD//85z/xhz/8ATt37kSTJk0AAKtWrcJZZ52Fli1b4oEHHoDP58O0adNQVFRk6X1/8MEHqKiowI033ogmTZrgp59+wvTp07F792588MEHuuf6fD6MHj0aJ510Ep588kl89dVXeOqpp9C5c2fceOONABRhdP755+O7777DDTfcgJ49e+Ljjz/GhAkTLK3nsssuwwMPPIDZs2fjhBNO0O37/fffx7Bhw9CuXTscOnQIr776KsaPH48///nPKC0txWuvvYbRo0fjp59+CgpzhuO+++7DQw89hLPPPhtnn302Vq5ciTPPPBM1NTW6523duhWffPIJLr74YnTs2BG///47XnrpJYwYMQLr1q1Dq1at0LNnT0ybNg333XcfrrvuOgwbNgwAMGTIEMN9M8Zw3nnnYdGiRbjmmmvQv39/fPnll7jzzjuxZ88ePPPMM7rnWzkuoqWyshIjR47E5s2bMXnyZHTs2BEffPABJk6ciOLiYtx6660AgIULF2L8+PE4/fTT8dhjjwEA1q9fjyVLlqjPmTp1Kh555BFce+21GDRoEEpKSrB8+XKsXLkSZ5xxRkzrJIiEwAiCcCyTJk1i8n/TESNGMADsxRdfDHp+RUVF0H3XX389y87OZlVVVep9EyZMYO3bt1dvb9u2jQFgTZo0YUeOHFHv//TTTxkA9p///Ee97/777w9aEwDm9XrZ5s2b1fvWrFnDALDp06er940dO5ZlZ2ezPXv2qPdt2rSJpaWlBW3TCKP398gjjzCXy8V27Nihe38A2LRp03TPPf7449mAAQPU25988gkDwB5//HH1vrq6OjZs2DAGgM2cOTPsmgYOHMjatGnDfD6fet8XX3zBALCXXnpJ3WZ1dbXudUePHmXNmzdnV199te5+AOz+++9Xb8+cOZMBYNu2bWOMMXbgwAHm9XrZOeecw/x+v/q8v//97wwAmzBhgnpfVVWVbl2MKd91RkaG7rNZtmyZ6fuVjxX+mT300EO651100UXM5XLpjgGrx4UR/Jh84oknTJ/z7LPPMgDs7bffVu+rqalhgwcPZrm5uaykpIQxxtitt97K8vPzWV1dnem2+vXrx84555yQayIIJ0MhV4JIQTIyMnDVVVcF3Z+VlaVeLy0txaFDhzBs2DBUVFTgt99+C7vdSy65BI0aNVJvc7dm69atYV87atQodO7cWb3dt29f5Ofnq6/1+Xz46quvMG7cOLRq1Up9XpcuXTBmzJiw2wf076+8vByHDh3CkCFDwBjDqlWrgp5/ww036G4PGzZM917mzZuHtLQ01bEDlJy1m2++2dJ6ACXvcffu3fjmm2/U+2bPng2v14uLL75Y3abX6wUA+P1+HDlyBHV1dTjxxBMNw7Wh+Oqrr1BTU4Obb75ZF6a+7bbbgp6bkZEBt1v5M+/z+XD48GHk5uaie/fuEe+XM2/ePHg8Htxyyy26+++44w4wxjB//nzd/eGOi1iYN28eWrRogfHjx6v3paen45ZbbkFZWRn+97//AQAKCwtRXl4eMnxaWFiIX3/9FZs2bYp5XQSRDEjQEUQK0rp1a1UgiPz666+44IILUFBQgPz8fBQVFakFFceOHQu73Xbt2uluc3F39OjRiF/LX89fe+DAAVRWVqJLly5BzzO6z4idO3di4sSJaNy4sZoXN2LECADB7y8zMzMolCuuBwB27NiBli1bIjc3V/e87t27W1oPAPzpT3+Cx+PB7NmzAQBVVVX4+OOPMWbMGJ04fuONN9C3b181P6uoqAiff/65pe9FZMeOHQCArl276u4vKirS7Q9QxOMzzzyDrl27IiMjA02bNkVRURHWrl0b8X7F/bdq1Qp5eXm6+3nlNV8fJ9xxEQs7duxA165dVdFqtpabbroJ3bp1w5gxY9CmTRtcffXVQXl806ZNQ3FxMbp164Y+ffrgzjvvdHy7GYIQIUFHECmI6FRxiouLMWLECKxZswbTpk3Df/7zHyxcuFDNGbLSesKsmpJJye52v9YKPp8PZ5xxBj7//HPcdddd+OSTT7Bw4UI1eV9+f4mqDG3WrBnOOOMMfPTRR6itrcV//vMflJaW4rLLLlOf8/bbb2PixIno3LkzXnvtNXzxxRdYuHAhTjvttLi2BHn44Ydx++23Y/jw4Xj77bfx5ZdfYuHChejdu3fCWpHE+7iwQrNmzbB69Wr8+9//VvP/xowZo8uVHD58OLZs2YLXX38dxx13HF599VWccMIJePXVVxO2ToKIBSqKIIh6wuLFi3H48GHMnTsXw4cPV+/ftm1bElel0axZM2RmZho24g3VnJfz888/Y+PGjXjjjTdw5ZVXqvfHUoXYvn17fP311ygrK9O5dBs2bIhoO5dddhm++OILzJ8/H7Nnz0Z+fj7Gjh2rPv7hhx+iU6dOmDt3ri5Mev/990e1ZgDYtGkTOnXqpN5/8ODBINfrww8/xKmnnorXXntNd39xcTGaNm2q3o5k8kf79u3x1VdfobS0VOfS8ZA+X18iaN++PdauXQu/369z6YzW4vV6MXbsWIwdOxZ+vx833XQTXnrpJfzjH/9QHeLGjRvjqquuwlVXXYWysjIMHz4cU6dOxbXXXpuw90QQ0UIOHUHUE7gTIjofNTU1eP7555O1JB0ejwejRo3CJ598gr1796r3b968OSjvyuz1gP79McZ0rSci5eyzz0ZdXR1eeOEF9T6fz4fp06dHtJ1x48YhOzsbzz//PObPn48LL7wQmZmZIde+dOlS/PDDDxGvedSoUUhPT8f06dN123v22WeDnuvxeIKcsA8++AB79uzR3ZeTkwMAltq1nH322fD5fPjXv/6lu/+ZZ56By+WynA9pB2effTb279+POXPmqPfV1dVh+vTpyM3NVcPxhw8f1r3O7XarzZ6rq6sNn5Obm4suXbqojxOE0yGHjiDqCUOGDEGjRo0wYcIEdSzVW2+9ldDQVjimTp2KBQsWYOjQobjxxhtVYXDccceFHTvVo0cPdO7cGVOmTMGePXuQn5+Pjz76KKZcrLFjx2Lo0KG4++67sX37dvTq1Qtz586NOL8sNzcX48aNU/PoxHArAJx77rmYO3cuLrjgApxzzjnYtm0bXnzxRfTq1QtlZWUR7Yv303vkkUdw7rnn4uyzz8aqVaswf/58nevG9ztt2jRcddVVGDJkCH7++We88847OmcPADp37ozCwkK8+OKLyMvLQ05ODk466SR07NgxaP9jx47FqaeeinvuuQfbt29Hv379sGDBAnz66ae47bbbdAUQdvD111+jqqoq6P5x48bhuuuuw0svvYSJEydixYoV6NChAz788EMsWbIEzz77rOogXnvttThy5AhOO+00tGnTBjt27MD06dPRv39/Nd+uV69eGDlyJAYMGIDGjRtj+fLl+PDDDzF58mRb3w9BxI3kFNcSBGEFs7YlvXv3Nnz+kiVL2Mknn8yysrJYq1at2F//+lf25ZdfMgBs0aJF6vPM2pYYtYiA1EbDrG3JpEmTgl7bvn17XRsNxhj7+uuv2fHHH8+8Xi/r3Lkze/XVV9kdd9zBMjMzTT4FjXXr1rFRo0ax3Nxc1rRpU/bnP/9ZbYMhttyYMGECy8nJCXq90doPHz7MrrjiCpafn88KCgrYFVdcwVatWmW5bQnn888/ZwBYy5Ytg1qF+P1+9vDDD7P27duzjIwMdvzxx7PPPvss6HtgLHzbEsYY8/l87IEHHmAtW7ZkWVlZbOTIkeyXX34J+ryrqqrYHXfcoT5v6NCh7IcffmAjRoxgI0aM0O33008/Zb169VJbyPD3brTG0tJS9pe//IW1atWKpaens65du7InnnhC10aFvxerx4UMPybN/r311luMMcZ+//13dtVVV7GmTZsyr9fL+vTpE/S9ffjhh+zMM89kzZo1Y16vl7Vr145df/31bN++fepzHnroITZo0CBWWFjIsrKyWI8ePdj//d//sZqampDrJAin4GLMQT/fCYJokIwbN45aRhAEQcQA5dARBJFQ5DFdmzZtwrx58zBy5MjkLIggCKIeQA4dQRAJpWXLlpg4cSI6deqEHTt24IUXXkB1dTVWrVoV1FuNIAiCsAYVRRAEkVDOOussvPvuu9i/fz8yMjIwePBgPPzwwyTmCIIgYoAcOoIgCIIgiBSHcugIgiAIgiBSHBJ0BEEQBEEQKQ7l0IXA7/dj7969yMvLi2g0DkEQBEEQhB0wxlBaWopWrVrpRtzJkKALwd69e9G2bdtkL4MgCIIgiAbOrl270KZNG9PHSdCFgI+N2bVrF/Lz85O8GoIgCIIgGholJSVo27atqknMIEFnwIwZMzBjxgz4fD4AQH5+Pgk6giAIgiCSRrjUL2pbEoKSkhIUFBTg2LFjJOgIgiAIgkg4VrUIVbkSBEEQBEGkOCToCIIgCIIgUhzKoSMIol7h8/lQW1ub7GUQBEFYIj09HR6PJ+btkKAjCKJewBjD/v37UVxcnOylEARBRERhYSFatGgRU89bEnQEQdQLuJhr1qwZsrOzqRk4QRCOhzGGiooKHDhwAADQsmXLqLdFgo4giJTH5/OpYq5JkybJXg5BEIRlsrKyAAAHDhxAs2bNog6/UlEEQRApD8+Zy87OTvJKCIIgIof/7Yol/5cEHUEQ9QYKsxIEkYrY8beLBB1BEARBEESKQ4KOIAiiHtGhQwc8++yzyV5GyjJ16lT0798/5HMmTpyIcePG2brfWbNmobCw0NZtOgGXy4VPPvkk2ctoEJCgIwiCSAIulyvkv6lTp0a13WXLluG6666LaW0jR47EbbfdFtM2UpUpU6bg66+/Tvh+L7nkEmzcuDGi1zTk74kIhqpcCYIgksC+ffvU63PmzMF9992HDRs2qPfl5uaq1xlj8Pl8SEsL/ye7qKjI3oU2MHJzc3WffaLIyspSqx2dQm1tLdLT05O9DMIi5NARBEEkgRYtWqj/CgoK4HK51Nu//fYb8vLyMH/+fAwYMAAZGRn47rvvsGXLFpx//vlo3rw5cnNzMXDgQHz11Ve67cohV5fLhVdffRUXXHABsrOz0bVrV/z73/+Oae0fffQRevfujYyMDHTo0AFPPfWU7vHnn38eXbt2RWZmJpo3b46LLrpIfezDDz9Enz59kJWVhSZNmmDUqFEoLy833M+0adPQqlUrHD58WL3vnHPOwamnngq/3x92nS6XCy+99BLOPfdcZGdno2fPnvjhhx+wefNmjBw5Ejk5ORgyZAi2bNmivkYOufp8Ptx+++0oLCxEkyZN8Ne//hWMMd1+Ro4cicmTJ2Py5MkoKChA06ZN8Y9//EP3vKNHj+LKK69Eo0aNkJ2djTFjxmDTpk3q43LIla/jrbfeQocOHVBQUIA//elPKC0tBaCEff/3v//hueeeU13d7du34+jRo7jssstQVFSErKwsdO3aFTNnzgz7WW3fvh0ulwtz5szBiBEjkJmZiXfeeQcA8Oqrr6Jnz57IzMxEjx498Pzzz6uvq6mpweTJk9GyZUtkZmaiffv2eOSRR3TbPnTokOnx5/P5cM0116Bjx47IyspC9+7d8dxzz+lez0PcDzzwAIqKipCfn48bbrgBNTU16nP8fj8eeeQRdTv9+vXDhx9+GPZ91ysYYcqxY8cYAHbs2LFkL4UgiBBUVlaydevWscrKSsYYY36/n5VX1ybln9/vj3j9M2fOZAUFBertRYsWMQCsb9++bMGCBWzz5s3s8OHDbPXq1ezFF19kP//8M9u4cSO79957WWZmJtuxY4f62vbt27NnnnlGvQ2AtWnThs2ePZtt2rSJ3XLLLSw3N5cdPnzYdD0jRoxgt956q+Fjy5cvZ263m02bNo1t2LCBzZw5k2VlZbGZM2cyxhhbtmwZ83g8bPbs2Wz79u1s5cqV7LnnnmOMMbZ3716WlpbGnn76abZt2za2du1aNmPGDFZaWmq4r7q6OjZ48GA2btw4xhhj//rXv1hhYaHu/YYCAGvdujWbM2cO27BhAxs3bhzr0KEDO+2009gXX3zB1q1bx04++WR21llnqa+5//77Wb9+/dTbjz32GGvUqBH76KOP2Lp169g111zD8vLy2Pnnn6/7vHJzc9mtt97KfvvtN/b222+z7Oxs9vLLL6vPOe+881jPnj3ZN998w1avXs1Gjx7NunTpwmpqahhjwcfA/fffz3Jzc9mFF17Ifv75Z/bNN9+wFi1asL///e+MMcaKi4vZ4MGD2Z///Ge2b98+tm/fPlZXV8cmTZrE+vfvz5YtW8a2bdvGFi5cyP7973+H/ay2bdvGALAOHTqwjz76iG3dupXt3buXvf3226xly5bqfR999BFr3LgxmzVrFmOMsSeeeIK1bduWffPNN2z79u3s22+/ZbNnz9Z9B6GOv5qaGnbfffexZcuWsa1bt6qf3Zw5c9RtTJgwgeXm5rJLLrmE/fLLL+yzzz5jRUVF6mfBGGMPPfQQ69GjB/viiy/Yli1b2MyZM1lGRgZbvHhx2PfuBOS/YSJWtQgJuhCQoCOI1ED+Y1heXcva3/VZUv6VV9dGvH4zQffJJ5+EfW3v3r3Z9OnT1dtGgu7ee+9Vb5eVlTEAbP78+abbDCXoLr30UnbGGWfo7rvzzjtZr169GGOMffTRRyw/P5+VlJQEvXbFihUMANu+fXvY98XZsmULy8vLY3fddRfLyspi77zzjuXXyu/9hx9+YADYa6+9pt737rvvsszMTPW2LOhatmzJHn/8cfV2bW0ta9OmTZCg69mzp07M33XXXaxnz56MMcY2btzIALAlS5aojx86dIhlZWWx999/nzFmLOiys7N1n+Odd97JTjrpJN1+5e9p7Nix7Kqrrgr30QTBBd2zzz6ru79z5846gcYYYw8++CAbPHgwY4yxm2++mZ122mmmP2SiOf4mTZrE/vCHP6i3J0yYwBo3bszKy8vV+1544QWWm5vLfD4fq6qqYtnZ2ez777/Xbeeaa65h48ePD/POnYEdgo5CrgRBEA7lxBNP1N0uKyvDlClT0LNnTxQWFiI3Nxfr16/Hzp07Q26nb9++6vWcnBzk5+ero4YiZf369Rg6dKjuvqFDh2LTpk3w+Xw444wz0L59e3Tq1AlXXHEF3nnnHVRUVAAA+vXrh9NPPx19+vTBxRdfjFdeeQVHjx4Nub9OnTrhySefxGOPPYbzzjsPl156aUTrFd978+bNAQB9+vTR3VdVVYWSkpKg1x47dgz79u3DSSedpN6XlpYW9L0AwMknn6zrJTZ48GD1M1m/fj3S0tJ022nSpAm6d++O9evXm669Q4cOyMvLU2+3bNky7Pd244034r333kP//v3x17/+Fd9//33I58uI7628vBxbtmzBNddco+YW5ubm4qGHHlLD1BMnTsTq1avRvXt33HLLLViwYEHQNsMdfzNmzMCAAQNQVFSE3NxcvPzyy0HHdL9+/XSNwwcPHoyysjLs2rULmzdvRkVFBc444wzdOt98801dOL2+Q0URBEHUO7LSPVg3bXTS9m0XOTk5uttTpkzBwoUL8eSTT6JLly7IysrCRRddpMslMkJObHe5XJZy0KIhLy8PK1euxOLFi7FgwQLcd999mDp1KpYtW4bCwkIsXLgQ33//PRYsWIDp06fjnnvuwdKlS9GxY0fTbX7zzTfweDzYvn076urqLBWHcMT3zgWX0X3x+jxiIZrvbcyYMdixYwfmzZuHhQsX4vTTT8ekSZPw5JNPWtqneMyVlZUBAF555RWdGAWgjqc64YQTsG3bNsyfPx9fffUV/vjHP2LUqFG6/LVQ7+O9997DlClT8NRTT2Hw4MHIy8vDE088gaVLl1par7jOzz//HK1bt9Y9lpGRYXk7qQ45dARB1DtcLheyvWlJ+RfPaRVLlizBxIkTccEFF6BPnz5o0aIFtm/fHrf9GdGzZ08sWbIkaF3dunVTT/JpaWkYNWoUHn/8caxduxbbt2/Hf//7XwDKdzN06FA88MADWLVqFbxeLz7++GPT/c2ZMwdz587F4sWLsXPnTjz44IPxe3MSBQUFaNmypU5c1NXVYcWKFUHPlQXIjz/+iK5du8Lj8aBnz56oq6vTPefw4cPYsGEDevXqFfX6vF4vfD5f0P1FRUWYMGEC3n77bTz77LN4+eWXo9p+8+bN0apVK2zduhVdunTR/RMFeH5+Pi655BK88sormDNnDj766CMcOXLE0j6WLFmCIUOG4KabbsLxxx+PLl26GLpqa9asQWVlpXr7xx9/RG5uLtq2bYtevXohIyMDO3fuDFpn27Zto3rvqQg5dERovp4GuNOAU/+e7JUQRIOna9eumDt3LsaOHQuXy4V//OMfcXOWDh48iNWrV+vua9myJe644w4MHDgQDz74IC655BL88MMP+Ne//qVWPn722WfYunUrhg8fjkaNGmHevHnw+/3o3r07li5diq+//hpnnnkmmjVrhqVLl+LgwYPo2bOn4Rp2796NG2+8EY899hhOOeUUzJw5E+eeey7GjBmDk08+OS7vW+bWW2/Fo48+iq5du6JHjx54+umnUVxcHPS8nTt34vbbb8f111+PlStXYvr06Wr1b9euXXH++efjz3/+M1566SXk5eXh7rvvRuvWrXH++edHvbYOHTpg6dKl2L59O3Jzc9G4cWNMnToVAwYMQO/evVFdXY3PPvvM9PO1wgMPPIBbbrkFBQUFOOuss1BdXY3ly5fj6NGjuP322/H000+jZcuWOP744+F2u/HBBx+gRYsWlpskd+3aFW+++Sa+/PJLdOzYEW+99RaWLVsW5NjW1NTgmmuuwb333ovt27fj/vvvx+TJk+F2u5GXl4cpU6bgL3/5C/x+P0455RQcO3YMS5YsQX5+PiZMmBD1+08lSNAR5lSXAd8G2hGccjuQnpnc9RBEA+fpp5/G1VdfjSFDhqBp06a46667DHO/7GD27NmYPXu27r4HH3wQ9957L95//33cd999ePDBB9GyZUtMmzYNEydOBAAUFhZi7ty5mDp1KqqqqtC1a1e8++676N27N9avX49vvvkGzz77LEpKStC+fXs89dRTGDNmTND+GWOYOHEiBg0ahMmTJwMARo8ejRtvvBGXX345Vq9enZB+cXfccQf27duHCRMmwO124+qrr8YFF1yAY8eO6Z535ZVXorKyEoMGDYLH48Gtt96qa/A8c+ZM3HrrrTj33HNRU1OD4cOHY968eTH1eZsyZQomTJiAXr16obKyEtu2bYPX68Xf/vY3bN++HVlZWRg2bBjee++9qPdx7bXXIjs7G0888QTuvPNO5OTkoE+fPmpD47y8PDz++OPYtGkTPB4PBg4ciHnz5sHtthYAvP7667Fq1SpccsklcLlcGD9+PG666SbMnz9f97zTTz8dXbt2xfDhw1FdXY3x48frmm8/+OCDKCoqwiOPPIKtW7eisLAQJ5xwAv7+94ZjRrgYkxrqEColJSUoKCjAsWPHkJ+fn+zlJJ7Ko8BjHZTrf9sDZCS+2SZBWKGqqgrbtm1Dx44dkZlJPzyIxDJy5Ej079+fRq7FiYkTJ6K4uLhejxAL9TfMqhahHDrCHDGU469L3joIgiAIgggJCTrCHCYk2zLnVYARBNFweeedd3QtKsR/vXv3TvbyHMfDDz9s+nkZhbyJ1INy6Ahz/IKgI4eOIAgHcd555wW10uAkev7o4sWLE7q/aLjhhhvwxz/+0fAxp82QlZk1a1ayl5ASkKAjzBEdOn9waTxBEESyyMvL0zXdJULTuHFjNG7cONnLIOIIhVwJc8ihIwiCIIiUgAQdYY4uh44cOoIgCIJwKiToCHPEjjYUciUIgiAIx0KCzoAZM2agV69eGDhwYLKXklz8lENHEARBEKkACToDJk2ahHXr1mHZsmXJXkpyYZRDRxAEQRCpAAk6whw/5dARhNMZOXKkOoYJUOZ7hptY4HK5bOm6b9d2CGO2b98Ol8sVNFNXZPHixXC5XIbzZWOhPn63EydOxLhx45K9jLhBgo4whxw6gogbY8eOxVlnnWX42LfffguXy4W1a9dGvN1ly5bpZojawdSpU9G/f/+g+/ft2xf3prSzZs2yPOi9vtG2bVvs27cPxx13XML3Hel325C/J6dAgo4wh3LoCCJuXHPNNVi4cCF2794d9NjMmTNx4oknom/fvhFvt6ioCNnZ2XYsMSwtWrRARkZGQvbVEPF4PGjRogXS0hLfMtZp321NTU2yl+B4SNAR5ojjvkjQEYStnHvuuSgqKgrqgl9WVoYPPvgA11xzDQ4fPozx48ejdevWyM7ORp8+ffDuu++G3K4cct20aROGDx+OzMxM9OrVCwsXLgx6zV133YVu3bohOzsbnTp1wj/+8Q/U1tYCUJyXBx54AGvWrIHL5YLL5VLXLIflfv75Z5x22mnIyspCkyZNcN1116GsrEx9nIe8nnzySbRs2RJNmjTBpEmT1H1Fw86dO3H++ecjNzcX+fn5+OMf/4jff/9dfXzNmjU49dRTkZeXh/z8fAwYMADLly8HAOzYsQNjx45Fo0aNkJOTg969e2PevHmG+/ntt9+QnZ2N2bNnq/e9//77yMrKwrp168Kuk7/3hx9+GM2bN0dhYSGmTZuGuro63HnnnWjcuDHatGmDmTNnqq8xCrnOmzcP3bp1Q1ZWFk499VRs375dtx/ulH3yySfo2rUrMjMzMXr0aOzatUv3vBdeeAGdO3eG1+tF9+7d8dZbb+keF79bvo65c+fi1FNPRXZ2Nvr164cffvgBgBL2veqqq3Ds2DH1GJk6dSoA4Pnnn1fX0bx5c1x00UVhPytASSWYPHkybrvtNjRt2hSjR48GAPzyyy8YM2YMcnNz0bx5c1xxxRU4dOiQ+roPP/wQffr0UY/BUaNGoby8XLftUMffW2+9hRNPPBF5eXlo0aIFLr30Uhw4cEB9nIe4P//8c/Tt2xeZmZk4+eST8csvv+j28d1332HYsGHIyspC27ZtccsttwStw25I0BHm6AQdhVyJFIIxoKY8Of/Edj8hSEtLw5VXXolZs2aBCa/54IMP4PP5MH78eFRVVWHAgAH4/PPP8csvv+C6667DFVdcgZ9++snSPvx+Py688EJ4vV4sXboUL774Iu66666g5+Xl5WHWrFlYt24dnnvuObzyyit45plnAACXXHIJ7rjjDvTu3Rv79u3Dvn37cMkllwRto7y8HKNHj0ajRo2wbNkyfPDBB/jqq68wefJk3fMWLVqELVu2YNGiRXjjjTcwa9asqEc7+f1+nH/++Thy5Aj+97//YeHChdi6datufZdddhnatGmDZcuWYcWKFbj77rvV0WCTJk1CdXU1vvnmG/z888947LHHkJuba7ivHj164Mknn8RNN92EnTt3Yvfu3bjhhhvw2GOPoVevXpbW+9///hd79+7FN998g6effhr3338/zj33XDRq1AhLly7FDTfcgOuvv97QtQWAXbt24cILL8TYsWOxevVqXHvttbj77ruDnldRUYH/+7//w5tvvoklS5aguLgYf/rTn9THP/74Y9x6662444478Msvv+D666/HVVddhUWLFoVc/z333IMpU6Zg9erV6NatG8aPH4+6ujoMGTIEzz77LPLz89VjZMqUKVi+fDluueUWTJs2DRs2bMAXX3yB4cOHW/qsAOCNN96A1+vFkiVL8OKLL6K4uBinnXYajj/+eCxfvhxffPEFfv/9d3Wk2b59+zB+/HhcffXVWL9+PRYvXowLL7xQ9/8r3PFXW1uLBx98EGvWrMEnn3yC7du3Y+LEiUFru/POO/HUU09h2bJlKCoqwtixY1VhuGXLFpx11ln4wx/+gLVr12LOnDn47rvvgv4v2A4jTDl27BgDwI4dO5bspSSH7d8zdn++8m/r/5K9GoIwpbKykq1bt45VVlYqd1SXacduov9Vl1le9/r16xkAtmjRIvW+YcOGscsvv9z0Neeccw6744471NsjRoxgt956q3q7ffv27JlnnmGMMfbll1+ytLQ0tmfPHvXx+fPnMwDs448/Nt3HE088wQYMGKDevv/++1m/fv2Cnidu5+WXX2aNGjViZWXa+//888+Z2+1m+/fvZ4wxNmHCBNa+fXtWV1enPufiiy9ml1xyielaZs6cyQoKCgwfW7BgAfN4PGznzp3qfb/++isDwH766SfGGGN5eXls1qxZhq/v06cPmzp1qum+jTjnnHPYsGHD2Omnn87OPPNM5vf7Lb2Ov3efz6fe1717dzZs2DD1dl1dHcvJyWHvvvsuY4yxbdu2MQBs1apVjDHG/va3v7FevXrptnvXXXcxAOzo0aOMMeXzAsB+/PFH9Tn8OFu6dCljjLEhQ4awP//5z7rtXHzxxezss89Wb4vfLV/Hq6++qj7OP+f169er+5W/p48++ojl5+ezkpISS5+RyIgRI9jxxx+vu+/BBx9kZ555pu6+Xbt2MQBsw4YNbMWKFQwA2759u+E2ozn+li1bxgCw0tJSxhhjixYtYgDYe++9pz7n8OHDLCsri82ZM4cxxtg111zDrrvuOt12vv32W+Z2u7W/URJBf8MErGoRcugIc6gogiDiSo8ePTBkyBC8/vrrAIDNmzfj22+/xTXXXAMA8Pl8ePDBB9GnTx80btwYubm5+PLLL7Fz505L21+/fj3atm2LVq1aqfcNHjw46Hlz5szB0KFD0aJFC+Tm5uLee++1vA9xX/369UNOTo5639ChQ+H3+7Fhwwb1vt69e8Pj8ai3W7ZsqQtpRbrPtm3bom3btup9vXr1QmFhIdavXw8AuP3223Httddi1KhRePTRR7Flyxb1ubfccgseeughDB06FPfff7+lIpTXX38da9euxcqVKzFr1iy4XC7L6+3duzfcbu2027x5c/Tp00e97fF40KRJE9PPY/369TjppJN09xl9n2lpabo+qj169NB9JuvXr8fQoUN1rxk6dKj6uBliTmfLli0BIOR3d8YZZ6B9+/bo1KkTrrjiCrzzzjuoqKgIuQ+RAQMG6G6vWbMGixYtQm5urvqvR48eABRXrF+/fjj99NPRp08fXHzxxXjllVdw9OhR3TbCHX8rVqzA2LFj0a5dO+Tl5WHEiBEAEPT/QfzcGzdujO7du6uf35o1azBr1izdOkePHg2/349t27ZZfv+RkvhMSyJ10BVF+M2fRxBOIz0b+Pve5O07Aq655hrcfPPNmDFjBmbOnInOnTurJ5EnnngCzz33HJ599ln06dMHOTk5uO2222xNEP/hhx9w2WWX4YEHHsDo0aNRUFCA9957D0899ZRt+xDh4U6Oy+WCP45/X6ZOnYpLL70Un3/+OebPn4/7778f7733Hi644AJce+21GD16ND7//HMsWLAAjzzyCJ566incfPPNpttbs2YNysvL4Xa7sW/fPlXYWMHovSf684gFca1cyIZaa15eHlauXInFixdjwYIFuO+++zB16lQsW7bMUkWs+OMAUPJLx44di8ceeyzouS1btoTH48HChQvx/fffY8GCBZg+fTruueceLF26FB07dgx6D/x98PfA0wZGjx6Nd955B0VFRdi5cydGjx4d0f+5srIyXH/99bjllluCHmvXrp3l7UQKOXSEOeTQEamKywV4c5LzLwLHBgD++Mc/wu12Y/bs2XjzzTdx9dVXqyfLJUuW4Pzzz8fll1+Ofv36oVOnTti4caPlbffs2RO7du3Cvn371Pt+/PFH3XO+//57tG/fHvfccw9OPPFEdO3aFTt27NA9x+v1wucLXRjVs2dPVexwlixZArfbje7du1tecyTw9ycm/K9btw7FxcW6vLZu3brhL3/5CxYsWIALL7xQV3jQtm1b3HDDDZg7dy7uuOMOvPLKK6b7O3LkCCZOnIh77rkHEydOxGWXXYbKysq4vDcjevbsGZQ/KX+fAFBXV6cWfgDAhg0bUFxcjJ49e6rbWbJkie41S5YssZwLaITZMZKWloZRo0bh8ccfx9q1a7F9+3b897//jWofJ5xwAn799Vd06NABXbp00f3j4s/lcmHo0KF44IEHsGrVKni9Xnz88ceWtv/bb7/h8OHDePTRRzFs2DD06NHD1IEUP/ejR49i48aN6ud7wgknYN26dUFr7NKlC7xeb1Tv3Qok6AhzxF9e1FiYIOJCbm4uLrnkEvztb3/Dvn37dAnYXbt2VR2H9evX4/rrr9dVcIZj1KhR6NatGyZMmIA1a9bg22+/xT333KN7TteuXbFz506899572LJlC/75z38GnQA7dOiAbdu2YfXq1Th06BCqq6uD9nXZZZchMzMTEyZMwC+//IJFixbh5ptvxhVXXIHmzZtH9qFI+Hw+rF69Wvdv/fr1GDVqFPr06YPLLrsMK1euxE8//YQrr7wSI0aMwIknnojKykpMnjwZixcvxo4dO7BkyRIsW7ZMPfHedttt+PLLL7Ft2zasXLkSixYtUh8z4oYbbkDbtm1x77334umnn4bP58OUKVNiem+RcMMNN2DTpk248847sWHDBsyePduwoCQ9PR0333wzli5dihUrVmDixIk4+eSTMWjQIABKQv+sWbPwwgsvYNOmTXj66acxd+7cmN5Lhw4dUFZWhq+//hqHDh1CRUUFPvvsM/zzn//E6tWrsWPHDrz55pvw+/1RC/xJkybhyJEjGD9+PJYtW4YtW7bgyy+/xFVXXQWfz4elS5fi4YcfxvLly7Fz507MnTsXBw8eDPmdirRr1w5erxfTp0/H1q1b8e9//xsPPvig4XOnTZuGr7/+Gr/88gsmTpyIpk2bqk2L77rrLnz//feYPHkyVq9ejU2bNuHTTz+Ne1EECTrCHHLoCCIhXHPNNTh69ChGjx6ty3e79957ccIJJ2D06NEYOXIkWrRoEVGne7fbjY8//hiVlZUYNGgQrr32Wvzf//2f7jnnnXce/vKXv2Dy5Mno378/vv/+e/zjH//QPecPf/gDzjrrLJx66qkoKioybJ2SnZ2NL7/8EkeOHMHAgQNx0UUX4fTTT8e//vWvyD4MA8rKynD88cfr/o0dOxYulwuffvopGjVqhOHDh2PUqFHo1KkT5syZA0DJSTt8+DCuvPJKdOvWDX/84x8xZswYPPDAAwAUoThp0iT07NkTZ511Frp164bnn3/ecA1vvvkm5s2bh7feegtpaWnIycnB22+/jVdeeQXz58+P+T1aoV27dvjoo4/wySefoF+/fnjxxRfx8MMPBz0vOzsbd911Fy699FIMHToUubm56mcCAOPGjcNzzz2HJ598Er1798ZLL72EmTNnYuTIkVGvbciQIbjhhhtwySWXoKioCI8//jgKCwsxd+5cnHbaaejZsydefPFFvPvuu+jdu3dU+2jVqhWWLFkCn8+HM888E3369MFtt92GwsJCuN1u5Ofn45tvvsHZZ5+Nbt264d5778VTTz1luUEybyP0wQcfoFevXnj00Ufx5JNPGj730Ucfxa233ooBAwZg//79+M9//qO6b3379sX//vc/bNy4EcOGDcPxxx+P++67T/d/Ox64GLNYY98AKSkpQUFBAY4dO4b8/PxkLyfxbJgPvBsodb9oJnDchcldD0GYUFVVhW3btqFjx47IzMxM9nIIImnMmjULt912m+2jwAiFxYsX49RTT8XRo0dtnYwR6m+YVS1CDh1hDk2KIAiCIIiUgAQdYY4YcqUcOoIgCFPEFhXyv2+//TbZy3MUO3fuDPl5Rdoyh1CgtiWEOX7KoSMIgrCCOJ5LpnXr1glbx8SJEw0nGziJVq1ahfy84p1rFgsjR46EUzPVSNAR5tAsV4IgCEt06dIl2UtIGdLS0ujzigMUciXMIYeOIAiCIFICEnSEObocOmd2LicIEaeGQgiCIEJhx98uEnSEObqQKzl0hHPh43wimRNJEAThFPjfLnk0WSRQDh1hDoVciRTB4/GgsLBQHdOTnZ0d0dB0giCIZMAYQ0VFBQ4cOIDCwkJ4PJ6ot0WCjjCHUR86InVo0aIFAJjOXiQIgnAqhYWF6t+waCFBR5hDDh2RQrhcLrRs2RLNmjVDbW1tspdDEARhifT09JicOQ4JOsIcMYeOiiKIFMHj8djyx5EgCCKVoKIIwhxy6AiCIAgiJSBBR5hDOXQEQRAEkRKQoCPMobYlBEEQBJESkKAjzBFdOUYOHUEQBEE4FRJ0hDkUciUIgiCIlIAEHWGOXwy5kqAjCIIgCKdCgo4wh1GVK0EQBEGkAiToCHMoh44gCIIgUgISdIQ55NARBEEQREpAgo4wR9e2hCZFEARBEIRTIUFHmEOTIgiCIAgiJSBBR5ijm+VKOXQEQRAE4VRI0BkwY8YM9OrVCwMHDkz2UpILOXQEQRAEkRKQoDNg0qRJWLduHZYtW5bspSQXaixMEARBECkBCTrCHD8JOoIgCIJIBUjQEeZQ2xKCIAiCSAlI0BHmmBVFMAb85zbgvw8lfEkEQRAEQQRDgo4wRzfLVXDoyg8BK2YC3z6V+DURBEEQBBEECTrCHF3IVRB3vprA435qOEwQBEEQDoAEHWGOWdsSRjNeCYIgCMJJkKAjzDETbtSfjiAIgiAcBQk6whxTh85v/ByCIAiCIJICCTrCHDPh5qeQK0EQBEE4CRJ0hDlmgo4mSBAEQRCEoyBBR5hjRcSRoCMIgiCIpEOCjjDHbFIEVbkSBEEQhKMgQUeYY+bEUZUrQRAEQTgKEnSEOWZhVqpyJQiCIAhHQYKOMMdvMsuVHDqCIAiCcBQk6AhzmMksV7OedARBEARBJAUSdIQ5piFXqnIlCIIgCCdBgo4wxyy0SiFXgiAIgnAUJOgIc6w4dNS2hCAIgiCSDgk6whzTMCtVuRIEQRCEkyBBR5hjVhRBOXQEQRAE4ShI0BHmWGksTCFXgiAIgkg6JOgIc5jUh44x7TqHHDqCIAiCSDok6AhzZPeNCzyqciUIgiAIR0GCjjBHdt+4eJOdO4IgCIIgkgoJOsIcWaxxgec3qXglCIIgCCIpkKAjzJHFmurQUciVIAiCIJwECbpU55sngbf/ANTV2L/toBw6A4eOQq4EQRAEkXRI0KU6y14DNn8FHFhn/7aDcugCt6nKlSAIgiAcBQm6VMfINbNt23LI1SiHjkKuRAPmwHpg+gBg7QfJXglBEA0cEnSpjpFrZhdBRRFGVa5UFEE0YN44Dzi8GZh7bbJXQhBEA4cEXapj1BvOLuSiCCM3kEKuREOm/ECyV0AQBAGABF3qw5Lg0IlhVgq5Eg2VymLteusBSVsGQRAEQIIu9eHjuOLi0MmCLuDYMapyJQjs/FG7nts8eesgCIIACbrUJxk5dBRyJQhg+7fadcolJQgiyZCgS3XUvLY4nFBMR39RlStBYPt32nUSdARBJBkSdKkOMwiD2r1tl0e/Dz9VuRINnMpiYP9a7Tb9PyAIIsmQoEt11N5wNjtljAEI5OelZej3QY2FiYbOzh+pfQ9BEI6CBF2qE6+2JeL2POmB+wz2RSFXoiFybJf+Ngk6giCSDAm6VEZ00ewOuYrb83iVSyOHjqpcUwe/H6guTfYqzNm7Cji4MdmrsIb8A4oEHUEQSYYEXSojnkTi6tAFBB01Fk5t5v4ZeKIrULI32SsJpqoEeG008OZ5yV6JNfiPG3fAvebtgwiCIJIECbpURhRTdjsEIR26OApJIn7sXQXUVQIHNyR7JcFUFQO+aqB0f7JXYg3+f0H9sUMOHUEQyYUEXSoTz+IEI4fOb+DQUcg1dairVi59NcldhxHqMcVS40cCF3RpJOgIgnAGJOhSGV2Vnd05dMK20yRBR1WuqYkvIOi4sHMSqVZoQw4dQRAOgwRdKhPPXDbxBBUyhy4FTr6EQl3AmXOiQ5dqzapJ0BEE4TBI0BkwY8YM9OrVCwMHDkz2UkITT4dOFW0uwJ0WuI+qXFMaXyqEXAH4apO3Dquogo4XRZCgIwgiuZCgM2DSpElYt24dli1bluylhCaexQlcqLk9gqAzcujoRJYSMAbUVSnXHRlyFVy5VAjjk0NHEITDIEGXysSzUz0/qbo8gCtwmBhWuaZAeIzQu15OdMBSLuQaWC8JOoIgHAIJulQmrjl0XNC5NYfOaCoFhVxTA1+18XWnIDq9fgcKThkuiknQEQThEEjQpTLxzGXzG4Vc6/SX4vMIZ1Mn5M05PuSaCg6dHHKlxsIEQSQXEnSpTFxz6AInKJdHEXXiPlItPGaFmvJkryC+8Pw5IAVCrinwI4GKIgiCcBgk6FKZeIY+1aIIt4FDF8cJFclg62LgkbbA99OTvZL44fiQq/DDwImCU4Zy6AiCcBgk6FIZnUOXrKKIFHBTwrFnhSJgt3+X7JXED13I1eFtS1LB9VUnRWQolyToCIJIMiToUpm4ToowyKEzKopIhZNvOGoqlMuyA8ldRzxxukOXamF8XrhBIVeCIBwCCbpUJp5OmejQqTl09bSxMM+fq8+CTiyEcHpj4ZQQdNSHjiAIZ0GCLpVJRA6d2LbEsLFwPRB0tVzQ/V5/qxVFQUch19hRc+jIoSMIwhmQoEtl4hmm4jl5brfi0on7SLWKxHBwh85fC1QeTe5a4oXTQ64p27aEcugIgnAGJOhSmbi2LQlsWwy5MgOHrl6EXCu06+UHk7eOeCK6ck6sIhWPIyeuTyaosXA9dXYJgkgZSNClMvFsH6IripD70NWzKtdaoQdd2e/JW0c8EfvQObKxcIq5vtSHjiAIh0GCLpVJWFFEqBy6FAiPhUNsKlxfCyPEQghHhlxT7JiiPnQEQTgMEnSpTKLaloTKoatvIdd669A5vChCl5eZAiFXqnIlCMJhkKBLZRLdtsQoh87uhsbJoME5dA4UdKlaFJFGgo4gCGdAgi6ViWvbEl4U4ar/s1xrG4Cg081ydaKgS7UcOrkoggQdQRDJhQRdKsPi6JT5xaIIOYcujqHeZFCTIkURtZXA/l+iq6jUhVwdmEOXalWulENHEITDIEGXysQ1h05oW1Kf+9D5fXr3yskO3edTgBeHAjuWRP5ax4dcU8z1pSpXgiAcBgm6VCaeYSrDWa71sMq1tkJ/u9zBgu7IVuXy8ObIX0ujv+wlqCiC+tARBJFcSNClMvF06HRFEYHDxLDKNcWdCTHcCiiNhZ3qOtZVKpfymi29NoVCrikp6FL8/wFBECkPCbpUJq6TIoxy6AL701UkOlT8WIWLo7QsAC7lM604nNQlmVIbg6DzOd2hS7EqVx8JOoIgnAUJulQmrg4dz6EzmOUqFkWkwsk3FFwcZeYDOU2V607No+OCrro08tfWUQ6drZBDRxCEwyBBl8rEsx8cF4gut+DQ1cPGwjyHLj0byGmmXHdqpSsv3rDDoXNazpc/1apcqSiCIAhnQYIulUlEDl3YoogUF3RcHHlzgVwu6Jzq0MUg6MRKXsB5Ll2qVU5T2xKCIBwGCbpUJp4nQbFtSaiiiFQ4+YZCFXTZQG5z5bpTHTruJtaURf5aedyX0wRdqoZc0zKUSxJ0BEEkGRJ0qUxcJ0WEKoqohyFXbw6QW6RcLz+YvPWY4fdp0wmiEXQ+qbLVafNcdUURqRBy5ZMiKORKEIQzIEGXyiRklqtBUUS9cugC4ig9G8huolx3YpUrL4gAogy5yg6dw1qXpHrbEsB5eYkEQTQoSNClMnFtWxLYtmEOXX2qchUcOn5ydmJSvijoqu1w6Bwm6FIpL9Pv1/5/6AQduXQEQSQPEnSpTMIaC4dw6OpTyNUdCJ85UaTWxerQSQLOaaI1lapcxWOeBB1BEA6BBF0qk4jRXy63IOiMqlxT/CQmhlw9UnsWJ1ErVKlGVRQhCzqHOXSpFHIV10eCjiAIh0CCLpWJp0MnhlxdkqBLpZNvONSQa25wv71YOboD+O9DQJkNRRY6hy5FiiJWvQ0sn2ntuak0KUJ0EEnQEQThENKSvQAiBuJZnKALuYboQ5fqIVexbQkPudoV8vthBvDTS4r7N+z22LYl5tD5ahRBluY1f75MotuW1FUD/7lVOVZ6XwBkFYZ+fiq1LdE5dOnadRJ0BEEkEXLoUpmEtC1x63PoGAMgVPM5PYE9HLUBQZeerZ2czdpmMAYc3mK9mrHyiHJZVRzTEgHoBR2grdsqvLEwF+fxDrlWlwaEDwPKD4V/fkoJOjGHjgQdQRDOgARdKqOrcrX5ZOIXGwvzUKQvWMAxX2q3axAnRci5gjKr3gKmnwD8+Ly1bfNq1Nqq0M+zgjzpIdJKV+7IZeQFthdnh04MC1dYEHSpFMbn63OnaekIAAk6giCSCgm6VCauOXRCY2EXnxThM95PKp/I1Bw6CyHXPSuVy4MbLG6bC7qK6NfHkR26SCtdeVEEF3TxdujE9Vnp65dKVa46QSf8CU3l/wcEQaQ8JOiSzdHtwL41QNWxyF+bkMbCUg6d0X5SOezKQ5feHMGJNBEUJXuVS9ktM4OLGlmMRUOQoIvAofPVaULcywVdnB060UG0FHIViyIcfjzx4yNI0KWwU00QRMpDgi7ZvD8BeGk4sHNp5K+NRw6d3x9onGrUtqTOeD9OD5GFgouu9JzwbUtKA4LOqkBTHTobBF1dLIJOcOOSEnK14NClVMhVdK9d2v3k0BEEkUSoyjXZpGcrl9GE5ex26BgDXh+tCIBOI5X73HIOncHJNhmVrpVHgYwCpWgjFsRJEdy18pkIiqgdOjtCrtI+Iwm5ij3oMvOVSyeHXM0c0u1LgNxmQNOusa0tVnQhVxcAFwBGgo4giKRCDl2ySc9SLqNxcXQTG2w4mdRWALt/UkLAPEwmz3I1Kr5IdIjs4AbgiS7AZ7fFvq0ao5CrgaCrrdKESTIcOnkbkRRFcKHqcmvHW7zz1CJ16MJVuR7bA7xxLjD7ktjXFiuqoAvkXPKwKwk6giCSCDl0yUYVdFG4OHZPihCdnOoS5dLt0Vd/GoZcEyzo9v+snFT3r41tO4xZb1tSuk+7bsWhY0yocrXBoYsm5OqrVYQ5F3SeDOUfEP9ZrqJDZyWHLlxPxSNbFMFUvEP5bMVQZ6LxCTl0gCLomI8EHUEQSYUcumSjhlyjceiEJGw7wp46QVeqXIqzXMWiCF27hgQLOi5mYs0Dq6vWTsKiQ2cUcuXhVsDad1VXrX0uVkO0oYgm5PrRNcAzvYDff1Vup3m1yQZxD7lG6tAJn7mRe1i6X3teNLNs7UTMoQPIoSMIwhGQoEs2doVcbXHoBNHABZ0uh04oijAaCZYouPMVqygRhUG4kKvo0Fn5rsRtJ6so4uBGRWTsWa7cTsvUpkvEO+RaHWEfunAhV/Hzj6Yi3E7EHDqABB1BEI6ABF2y8eYol7EWRdjt0FUFQq5mjYVdntACKJ7Y5dDxcGtapiJQQ4VcS/Zo1604bjWlwn5s7EPHxYMVl4q/D+4uJivkWnEk/PN1BT5Ggm6/dt2OyRuxQIKOIAgHQoIu2diWQ2fDycRnEHKVnTjRoRNDsYmEr80uh46HvdXGwkYh1yQ7dHwb2U0C27eYQwcAx3Yrl2leTbTGuw+duL6asvDTMnR96MKEvJ3i0HmoKIIgCOdAgi7ZxCLo4unQqTl0LimHThgJlqyQq+rQxSroeMuSXOVS7LcnE7FDJwq6itibzvJ9ZjdVLq1UufL3wQWdJwNIS5RDJ61PzKMr2QuU/q5/PGzIVXDoKotjXl5MqA6dnENHjYUJgkgeJOiSTUxFEXGscuXhSLEoQpdD50bY2afxQs2hizEPTJ0SEfgOQoZcpaKIcCfv6lL97VgLI/jxkRMQdFZCrj4p5JomhFzj7tBJ6+N5dHU1wPODlWbaZiIu5XLoAhW35NARBJFESNAlm1iKIsK5GpFi5NoENRYWc+iSFHKtsbkoQg258irXMG1LwMILIlnQxBp2VQVdUWD7Vhy6wPvgn1NahlAUkWhBF3DoqoqVf2X7lebQHPEYkkPejFEOHUEQRBhI0CWbmCZF2N22xMBF0oVWHVblatbo2CpiU2FAy6ED02/X79MLCiD89yULrlgFXZ3s0FnJoZOEkUdoW5LokGt5QNCJx5jYn84foiii8qhevDsm5Eo5dARBOAcSdMnGzkkRsebwGDleokMHpp3MklrlKoQzY3HpZEHHZ7kC+rBr2QHls3a5tZN3uCR/2x26wP5Uh85KyFVy4dIyhD50cXbouOjOa6lccodOFJJiO5NQIVdZTCc95Ep96AiCcB4k6JKNXbNcjW5HipFrI4ZWAa1VSFKrXAX3JxaniX/mcsgV0IsKnoOW1xJICwhwuS+cTJBDF2PrEu5s5URSFCGFjj1erSgiUSHXwvbKpZpDZ+LQ6fJBpXXrwt1IfsjVaFIEQIKOIIikQoIu2cRSFCGHOmMNfRqFXN1uzdUBNCEjulV2tEyJBFEsxSJM+Gcuty0B9Hl0vMI1r6XgqIZx6GTBFbNDFxCE2RaLIvz+YIGRlpn4PnSF7ZTLiBw66TgOEnTJdugoh44gCOdBgi7ZxBRylR26WAWdgThyuTVXB9DWKU+QSCR2OXRcwPL3Z+bQcUGR30r7vsI6dHLINUaHLijkWqaF2Fe+Cbw+RspJMyjsSMtITB86xjTR3Sjg0JUbOXRCK5NQOXT88/fmKZeOyaEjQUcQhHMgQZdsuDsUzXxKWcDFw6HjIVdeAMGFSbKqXP1+rd0IYJNDFxBpbtF1FEQFn3SQ01RxuQALOXQ2OnSMBRdFMJ/2ff34IrDze2DDPO01RpW6iQq51lYACIhNNeQaEG/i51ZhEnKV185z6Iq6K5dOceg8JOgIgnAOJOiSjaMcOpOiCEATAqJDl4wqV1koxSJMVIcuU7tPnRYhiAq1sjcNSA88N5E5dL4a7bvmkyIA5UcAY8DR7crtgxu0x0wdOl7lGkdBp/44cQEFbZSrFeGqXC0URTTroVwa5dBVlQDTBwDz7ox21dbxC8cDIPSho8bCBEEkDxJ0yYY7dHWVkeeiyc+PVVgZVYxy0caFQI3o0Akh10Ob9eOx4oUslGIqiuAOnSDojJoLM2E6RppFAS47rrE0Fhb35c0B0gNVuTVliijijqUo6IwcOl2Vaxxz6HhTZW+OFiI2CrnqcujEY1dqG8NDrkVc0Bk4dHtXAYc3A+v+HdPSLeGnogiCIJwHCbpkwx06IPKTvuzIxaPKNcihCwg6t1v5ByiOyYtDgddHx7Z/I+ReanKxgS0OnfAdGE2/UJspuzXxZ7VtidrmJIaQq3pcuBRBxtusVJdp7hwQXtCJo7/iGXJV28HkaiHiyiOKSBOPMV0OnfQ9i4JaDbn2DGy/LPj9lR9ULuUJHfGAcugIgnAgJOiSjSjoIj3pyyeQuOTQBQ4R7uzwNYoNh0v2Kq8t3mGtnYZVSvYCT3QGPr9Du69GOmHb7dAZhly5Q+ey3raEC4usxoF9xRByFatxXS5N0NWU6wXdsZ2amDIMuXoTG3L15gBZjZTrzK98d2YOXdCxHBBNfr8g6Lppj8sunZqjVx7/FADTWa4k6AiCSB4k6JKN26O1koj0pC+fuOKZQ6cKOu7QpWkOhSjiyg/EtgaRvasU92/LIu2+IIfOjipX0aEzqNzlJ2q3x3rbEi5qeMgxFodOFp4ZuYF9SA4dABzaqFzKziYgOXRxDLnysLg3RzluxGbMurYlh7W8s6AWPIH1lx8MHNcuIK+VVukqCzoxH8/KFI1YUHPoaFIEQRDOgQSdEzAqjGAsvNtlu0NnlEMXOESMiiK42BNPoGU2CjrenkKc+RlUFGHgRFmFizLLOXTuyNuW5HJBF4NDx/fFhac3IOiqS4Di7frn8rBrUosiAt9RRp7e1ayt0Dt0/jqtwEEOuXJByh/PLFCqSjMLlNty6xLR7Yt32NWJIddNXwEzzwYOb0neGgiCSCok6JwAD6GJJ/1PbgSe7AZs+9b8dUE5dHFqWwKEDrmKIkse0xQLXMhVFWtJ8rLIjakPnSSUAO0k7TNw6FyeyNuW2OLQScKzUUflcv8vwNEdyvXMQuXy4G/KZdiiiASFXAH9Dxb5++J5dEEteOq014jbyCpULuVK1/IECjonTopY+x6wYwmw8YvkrYEgiKRCgs4JpAsOBmf7EiUf6IMJQPFO49fJbRJirnI1OMnLRRF1Bg6deAK106HjJ23mV9woIDiHLqY+dAYOnVHIVVcUYfBdyfj9BiFXGxw6vu/2g5XLHd9rIdeuZyiXB3nINVxRRHX82mxUCyFXQD8NRf7RwJ21oKKIwG0uAPm6uXCVBV2FUGBhZx6nEU7MoePfd7xHuhEE4VhI0DkBWSQwplXtVRwG3rvUOEQWlEMnnFB+XwdsXRzZOiJy6NxCyFVo0VH2e2T7DIUYVuMn8Hg7dKFCrm7BoQtVkVxXCbWxrirobGhbwtfZbohyuWcFcGy3cr1roMKYO3R8/WLfOrEoAogtXB0KNYcuEBoWw9RBgu6wcbsevn45z5GHXEPl0HHxHy9M+9AlUdBxkRmv75QgCMdDgs4JyPNca8o1sZFRAOz/Gdj5Q/DrQk2KePcS4M1xwJGt1tdhWBQh59Dxoggh5CqKLDsFnejC8PBrUA5dLIIu8Fojh04XcjVy6EKEUNXPwwVk8ypXG0OuTTorQtFXDYApx0+HU5THjm5Tnu8TBB1P3vdkSIIuTm6O2LZEXLeRQ1d+yDhVgB/LskPHQ65yDh3/AQQkLofOIxdFJLGxMBeT5NARRIOFBJ0TkEUCPzmlZQGtT1Cul+wNfp3ZpAi/DyjeBYApoVurGBZFcIdOKooQGwuLYVBbHbqjwdeDHDobRn9ZrXJ1uaw5dGKVZ7pBfmSkyE6iywW0G6w9XtgeyGuhuFfMrzTYVZvfpmsuYVqmfi5v3AWdHHKtCD7GKg7pP2suPtWQqzTNw8ih8/v0x0pDLIpQHToSdATRUCFBZ8CMGTPQq1cvDBw4MDE7FE94gJYPlFME5LVUrvNu+SJmrR4qi6GG/Hb9aH0dIRsLy21LxBy6ODl0ogujOnQR5ND5fcBv84Cyg8aP1xnk0IWbFGHFoRMdqlhGu3HkwgAAaD9Eu96ogyLyGndSbh/bpTmMnnSgee/A89rrndVYwtWhUKtcpZCr6NBxcVp+WH8cqzl+csg1RA5dxRGoxzuQAEHHxbKDcuj4Z0ghV4JosJCgM2DSpElYt24dli1blpgdmjl0OU2BfC7oDKpHzdqWiAniu36yvo6QjYUNHDr+WLzaluhCroHrkUyK2Pgl8N54YME9wY8xZuLQGTQW9hu1LbHq0EliPRqMBJ3o0DXqEHicj5Gr0kSHJx24eCYwaRnQtGvgvjiP/wrKoROLIgL7LGitXFZIIVcu3CJx6MSWJeL+40VQDp0TBB3l0BFEQ4cEnROQiyJUQRfGoQsKuQZuVx7R7ju0MeBgWICLI36iAjQ3J00qinC7jRsLlx2wr1O/oUPHxUKgwWwol6k0EKbmhQMivhqoro4YhjQa/WVUFGHJocuxx6GTRQ0AtOijfQZc0Ik95nxCyDUjTz9lgX+XcSuKkEKuaQY5dPkBQVd+SHLoAs+Vc+i4i2qUQ1cuCbq4F0XwkCvPoXNAUQTl0BFEg4cEnROQiyJEhy6vhXLdiqAzcugA6y4dP9nycVWAMClCKopwCSHXWqHKlfmsC8hQMBY6h44XG4RymXgxgVEIThRYovNlGHKNsChCbKxrVdCFarVh5NC5PUDPcwG4gHYnK/eJLUm4WPMI4pzDv8t4hVyrTapcxRy6gjbKZYUk6OTPP8ihK1QudSFXWdA15Bw6cugIoqFCgs4JBAk6nkPXVHDoDEKuZqO/ZEFlNY+OFxhkC4JOdegMJkXwx2TsyKOrKdOH4rgjw8USb8cRqiiCFxMYheDkgfeckEURbmtFEWIfNiuTJb59Cni0nXkTaSNBBwDnPgPcthZo1V+5LTYNFosiZOI9/su0KMLIoTusfdYuT4iiCJ5DZxByDXLoEtVY2Ik5dOTQEURDhQSdE+AnPH4i1IVcuUO3P7hfl1nbEu7QcScmJoeO59B59c8Rq1xl7BB0clsK1aELnKy5oLPk0BkIOlEk8ZAZILQtEXPouEMXaVGExZDr9iXKd7n/Z+PHjfrl8bUXttNuG4VcPQaCjt8Xr/FfZn3oaiu178Qoh87tERw6PilCdujylcsqIazKBR1//3F36BycQ2c08o0giAYBCTonYFoUUQTkNleu+2v1uXGAedsSLug6jVAu96wIf/JmTBNHoRw6jtujiT0ZOwSdPAmA366RQq4hHboq/WuMHhPz0oBgQQHE0LYkV18UYdanrDxQSGJ2MjaaaGGE6Lz5Qwg67oLFOirODLEoBDBuLJzTLHBflRaGdadprpfPxKHjP1LEz4qHXHkuYcImRciNhZPZh46qXAmioUOCzgkEFUUETlDZTZUTMu8jJufRBbUtCdzmwq/tICVxvq5KGxFlhhiqyWqkXVdz6CRh4DIIuXKnwhaH7qjx7Wop5BoqxMQFcm1F8GdlFsYMFXJ1W3XoREEnbL/isDK9Q2xaDGjft9l7kUd/maFz6KTEfREjF9JOuENp2LYkIN640wZIeZnS5682Fg5sw2Ow9nJZ0CWrsTCFXAmCSB4k6JyAnEPHHYecpsqlGHYVMaty5Tl02U20bcjunozoOOkcOqltCUescuXwRHc7WpfwkCs/kVceDQgVyUUMFXIV35M4nkx8THbojNqWsEjblgghVzFMuuBe4M3zlUHqHL9fc2RloQcoJ2o+n5VXtZqhOnQ1YRw6g0peu/D7NYGWLufQVWifG8+FA6TK6TA5dGKeIIc70o06KpcJq3KlHDqCIJwDCTonIDoY4hxX7syZtS4xrXIVBB0XPnLlq4xY8SiebM1CrmKVK4c7JHaGXPk2K4/qQ6dZFkKuoosmh13NHDruAJk1Fk4T3FSzEBsXNN5sZXtchGz+SrkUhXlVcej8p+WvA4c2KN9Jl1HG+1PXLvSXU1vQhMih8xsIyFgRt8nbo+jalgSOM2+OJoTUZtVpgkPHq1yr9dvg79Ffp+WUcoeuMRd0VOVKEETDgwSdExAdDPEEH7FDJ+XQZTXWhE+4ViLiiVN0gtSQq1f/fKMqVy6+Sm0siuAn6boqIfk9Q0u4t+rQBY0MM3PouKAQ3Cu1KMKtz2Mza/uhisXA96pORQgIdfF7E2eQyu5K+SHgvw8q10/7B5DTxHh/HKOQq1HbEqOwcigYs15AoRvjFdiP4aSITONm1R7p81cLQrhDJwhULvrUHLoGLOgoh44gGjwk6JyAeMLjoiUjXzuJcYdOnucaLocuu4mWaxY25BoQJ54MxVni8JNVUFFEmv0OHWPAL3OBA79pDl1BG004HtupXGbkau6PZYeu1PixoBy6MCFXMYRq1opE3ra8D/F70wk6SWB994zSnqN5H2DAVcb7EjEqigiVQ2dV0L39B+C5vtaKDQwFHa/iLtPWlZapfYc8RO0OlUMnOXSA8h35/doPGC7+/bXx67Enrs1Jgi7SWa511cDhLfFbD0EQCYcEnRPg1YC1FZqg4+4cYN6LTq1SdGm3xUHl2Y2FkKvFHLq0DO0EDJg7dCFDrlHm0O3/GfjwKuUffw9ZjbXpAMW7lEtvrubu2O3QhWoszNtqqKFCkzw6NYcs8DnKgk6sLhU/KznkemC9cnnSdcZOm4xh2xJv8PPUHDoLgs5XB2xdpIT7j24L//xQDp3YiiYtQ1ubmkMnhFzlWa58G6JA9dUoxwkXUmILl3i6dI4UdHxShEWH7vPbgeknADu+j9+aCIJIKCTonIDOoZPy54DwOXSqCPEpjg6/Xwy5hnPofGLINUe737Rtids85Fp9LLpRV9zZO7AOKA64cVmFWtXtsYCgy8gTxlfFmkMnh1xDjP5yuQOtS8I0Cw5y6LL1j+scOqEprvxe1HyzXOP9yOiKIqyEXC0URZTu096/FZEkbpMLHVXQCcegJ8Ng+ohRUQQ/LgPPdXug/oDx1Wrh1owCZT+8ECOehRFO7kNn1aHbvVy5PLw5PushCCLhkKBzAmLbEi7oskWHziSHjp9YuNPB/JoTl5GviJ7sgBiynEPn1Qs6efQXx6ixcG5zzfGKJuwqiq4dPyiXmYWaoOOTFArb690oM4wcuvLDgZww7tBZCbkGih9UgcKT/MM5dCYhV9GhKxccOjnkauYimsGFvTj6K2TI1YKbI87BtRRy5ftN0/qz8ffPpzu40xShqc4HFosiJPdQ/gxcwmQPX40mMnkhT0Yg/zOeDp1PeI98TUDq5NAxpv1gqqmI35oIgkgoJOicgFgUESrkWn5Af9LnQkN0XNSCiIAIslwUIZw4041y6AyKIuSQa3o2kBtoGBtN2FVsLcLnw4oO3e7AxIuOw62FXOUcuu3fAU90UgoNzJr1GuWXiUURgPb5hHXoTEKuZjl0ssCS3alwqDNaazSnxrBtSQQ5dCV7tOtWXC85HAkEO5RqPpzBODl5bbVCKgBHrXSt1d4nPz5VQRfH5sKmIdckNhaWK6VXzwae66eF7UXKD2oiupYEHUHUF0jQOQF+wmd+7QQqhlxzmiqOGPPrBQCTHTqfviAC0HLowhZF8BNjhnHI1cihc0mHT3qWNtkiKoeuPPi+rEbaQHZOpxHWiiJkh27PCuX6nhXmDl2otiVcwIptOIyIpCiiLESVqxgGt4JhUUSMVa48zA0YT9yQMRR00vvn70cuinAZjP4ycik9gouqFvNwQRcIT8c1h86JIVeeQxc4htZ/pjQT3/5d8HO5OweQoCOIegQJOicgOhj8j60o6NweTSiJeXRGOXTcoeNCLlKHziMJOncoh04SC2mZwjql8LAVjASDGHIFlJFRRT0iL4qoKdM+m4rDwQ1rOWrIVXRCZYfOasjVQlGErSFXHoqsFdqWhHLoLOTQHRMdughy6ET3VhbNpg5dWrDYlKtcAUHQGRR/JCLkKucnOkLQSX3o+LFjJNrFqTHR5LoSBOFISNA5AU+6diJTBV1T/XO48yC6WGoOnTCbs0J26IS2JaFCQmJ4TxdyDZVDJ520XS7BoYsx5MoRQ66AEm51uTQhFrJtieTQlXNBdzS60V9q+NnOoggrIVeDSlUj1LxCG9uWRJxDZ8Why9Bf6iZFmM1yFQWdkEOnhpa5oAuMFItrUYQDq1zVHLoa/aXRd1y8Q7tu9H+OIIiUhASdU+An/SOB3lCF7fWPu43aaXCHjucU+fRNhQHNqfPXhXYtfIKgyywA8loBuS2E5rhhqlz5SdvukKvs0HUaoVyKUxGM8Pv1j9WUap9N5ZHI2paoOXSB9xvKofP7hVYbgc+u06lKFWaHYcptZjHkGqlDlyZ8JqpzFWsOnSjorDh0BjNk5fXLPeV0RRFhqlwBfcjVJz2eEIdOLopwgKCTq1xDOnSCoKOQK0HUG0jQOQXRxWh9ItDmRP3j6lByg1CgKOjkHLr0LGEeaoiwq3jidHuAm74HbvpB269hHzoDFyYvFodOcoDSshTxxPvQAUDHEdo6AeUEZuQ8yrNWa8o1QVdbofVEM3PozBoL83UBxg6deB/fdr9LgLt3AJ1GKre5QKwp14o/AIOQawxFEfIAeZFI+tCJDp3cnNkII4fOLTVkNnPoXFJRBGPCpAgjh642WLhyQWcl3y9aHJlD59PW4PeFFnTFJOgIoj5Cgs4piGG50+7VWiFwjBw6v5RDpwu5Cq6WlXmushuU1Uh7HWDg0Hm0/DrAwKGLJocuIG7yWgXWUKhc8nzCRh2ARgHnUhQqRq0aZEFXXaZ//6WBqRtWRn+p1cQWcujE+0QR43JpQoqf+MVwKyC5rywKh07IK7TStkQWkDI15VqDZyD6HDpAX01s6tCJgq5W71gaOnQ1+gkngNazryE1Fvb7AQg/any1WiqC0XcsOnTUtoQg6g0k6JwCF3QdhmlOjojoSnDU6kujoghh7qdaGCGcnGXkakGz/XNcHpOQqw1tSzqfplzmt1YuOwwDTrkdOG+6sB7hBG8UdpWTvWvKtCa0gDZGTXboQk2KsNK2hIsTT4Ze8ALa58VFj9hUGNALGPF7tuzQic5ViLYlciWpGWJBBKDl0Pl9wJGtSl9AMcFe3KZcMCP+YAly6ISQqzjLVRTl4vck9gqU32ciiyKc0odODOEDAaFr4tD5fXrXlRw6gqg3WJgnRCSE1scro5VGPRDszgHCiS5EyNWoKALQ3DpLIVcTN0gWdHKVa5rs0B1QnANZ1ACK+/S/x4CW/YDuY7T7uaDrcjrQ+VSgRZ/Atr3AqPv12xBFTl0NIGse2aGrLNYa2/L1AQYOnYHYCQq5hmhbYlZsAQSHOmXRK7op4vojrXKtqzYXVuJ94QSdmD8HaCLprXHAtm+U695c4I7fNCFlKuiygq/Lo79cbv3axHms4vGnK4owq3I1KYqorQLm3wl0OwvocY7xc8LhOIdOFnSC0JW/45K9+h8rJOgIot5ADp1TOO9fyomxzQDjx0MNjRddDS7axEICK61LzNp4cOT7XW59WI2fpHMCDp2/Vh+uEzmwDlj8CDD/r/r7ed6TNxfocxFQ1N18vW7BIbTi0Im9twCoIaqgHDqpyhIwKIoQRrUF7VdqWaLbduB74kKch1z5c8UTrZmYCYWYVxiyKMIkh27xo8Cb52v75k4Od0NrypTPhU/s4PeJLWqsCDq+Tv6+uJAXfyT4avUhZ/FHjq5tiVwUwatcTRy6Hd8BK98EvnnC+PFw+P2CM+6QxsLy9xjKoZP/H1DIlSDqDSTonILLpY0vMkI8iXGMRn/JUwoAfesSM9SO+yaCzi2FWOXbajWsVxOQZpWufI1yyJGfXMQ+eKFQW5cYCDrZoROLD3TbsFDlKjt0/L0aVeWGcuj469WQa8Chyw/kDIrfrdgX0MixNcKobYmRGDTrQ7fsVWDrYmD/z8ptHnJt2k25rC4BqoqhimHuxoriSRV0Ug6driiCNxY26kMnOKRGUyLE9+SvMy+KMGuxwtdqdYi9jCiQ+HtMtkMnh1z9QsPlIEEXyJ/jzbrJoSOIegMJulTBaP6mUdsStWWGcAKNpijCCPHEKvehE5Pew7Uu4UKitkLfR44LJKuCziivkMNFgtzUVsZSHzop0T/U9I2QDp1cFBEQtKqgE0OuEU6JACSHLoqQKxc7vAKYO3TNegQeFwpLMgs0USBWlMoVoJxQDh3/zMRjSjyWg0S3EHKViyLUSRFmIddK/TojRfzMuIhMtqAzCrmaCTpeENGsl3JJgo4g6g0k6FIF1aEzEho8TCXkToknQUshVwstMkS3R57lKgqYcIURoqMgnnhVQZdrvgYRsapThosBceKG4TZMcuhCtS3hjqeRQA7p0ElFEfz1uS0C94sh1zAhcCPU8CoTijNC9aET9ieGOKuKlUueQ1fEBV2pPkdTFU+CoJMH13N0RRGyQ2dS5WomatUWPgYza/mxY9Ywl98vu1pW0Tl0Ds2hq63Q3p+ZQ9esp3JJIVeCqDeQoEsV5LYlfuHkoeYiCX+cxZOglXmustNhhCgu3Gn6kKu4v7yAQDFrXSKegHihAmNCDp1Vhy7EtAgurHKaBD8mElTlauTQBUKMQYLOyKGzUBShdvUPfJf8/eqqXKNw6MTvTs1Ls5hDJ4ZN+XeiOnSBk7+/Vmv3kt1EW7fOoYsih06clStW4IZ16MQq18B9qqAzCbna6dA5RtDJTqvB98HhP7KadFYufdXRfxYEQTgKEnSpgkdyjsSTB39MdCXi4tDJIVeT8U6ROHTcDaqr1u63LOj4ZxLCocvIl5xFSeCY9qEzKorggi7E5xkq5Co7dPz98s/OMOQagUOXZiDoDB06oc0NRyfoipXL0kDIvEkX7THepiS7CeA1aBFilkOXHiKHjiM3Fjb7DIxGf/HnqCKz3LhIgX8/djh0/HhItqCT34v4fZg1qxar4CnsShD1AhJ0qYLcO0z8I84f44n/Hq++XYjq0IXoQydXCxohzhQV524CUsjVYg4doLlBohi1oyhCdMrEEG7jjvrnBeXQxTHkKjtj/HPg78Mw5BqBQycWqnCHymoOnezQ1dVokyFyioD0wHfCc7DEkGvUOXRys+o0fZWx0ZQIQBr9Jfehy9XemzxKDdDEiz9K8SU6kLxYJdmCTnbhagwENkf8oYPA+insShD1AhJ0qYIsNMSTh1ty6ORCAN7CxG6HTlflGkFRhLh2VdAFREFaVrC7Y7oewamREQVRhiDoeMUmxyw/K2RRREDQ1VUGnwwjKYpQBR136MQqV/59WGxZwlG/v4A7FbLKNYSg4y4dAtXX/DNUHbrGwlSGSEOugevye3N79FWu/DNIDxFy5eF2fmymCz8GjPLo+PcVrfgymlWb7MbCcsg0VMhV/OHGj1GzCnCCIFIKEnSpgtxOQ/wjLufQySdALkBqy43HVQEWq1ytFkUEBF1pFA6dVXcOiMChy9Pub9pV2oaFkKvs0Hlztc9cdukiKYrg++DfF59fCkTn0AHBIVarfehEl62yWBP/WYXK83k7EDHkqjp0giAwmyFrNCkiyKGTQ64mn4H646YmOIfOk6Y93yiPzq6QqyhY7exDV1MOrP9PZK5ZkKAL5dAJgs7LBZ1BP0WCIFIOEnSpgjw0XpdDF3hMdbmkE2VmgSYmSvcZb99KUURQDp1BY2FAy6Ert5JDF4Ogi8ahayIIOnHUlHqfQchVbizscgl5ibKg46LaQlEEkxw6QDsBR5NDBxiHMYPWYdCHTqw2rjoW3KCau3G8UCKrsSaUjUJ8QX3oDGa5yg6dLoeu1rzS12Mg6MRtiXl0MmrINUpB5zN4f3aGXH98HphzObD0ReuvkcWpUZEKR/x/rvZTpJArQdQHSNClCkFFEQYOHT9ZySFXlwtoHZhA8ctHxtu3IiBkh05X5Wow2snIOQNMHDphSoRVxL5rMjqHThCJYoK/UY86Q4dOqnIFzPPojBo7c4IcOl4UIYgd/l6i6UMHmIsfEfnHARAccuX5lly4coeOH3dmbUtMc+gsOnS6Wa5mbUvExsKSQweEFnQ18XTobBB0vJnz4c2Rr4kTyqETi0jUkCsJOoKoD5CgSxUstS3hOXQGouzEq5XLFbOM3QkrIT6rVa6hnDNAfzLlTWyjcuikkGttFfDtU8D+X/TvRxSJuc2AjMBEDjk0DZjk0PG2GhYKTSJpW6L2DBSey0VW1A6dnJcWqg9diBw6td+cJOg42U2MW4RYyqEzqXJ1p+nXpjaHtlDlqhN0IVqXxOrQxVvQ8fds5qQbrimSkKvgenpJ0BFEfYIEXargCRFy5UKBn8CMxETvC5Tw2bFdwKYFwY8bha5kdH3oTGa5AvrEdqO8Irty6ORxaJsXAl9PA766Xy+sRDGS0xTIDoQRDR06oypXqW0JEMKhs9K2xKTKVXws6hw66fszcujkimlA77JVFQeHXI0EnaFDZyboDBoLy2sTfySI0w7k70lsLFwXoUOn5tDFWBQhrt1WQRdYs1n+qeGaQoVcpcfqDBw6sybMBEGkFCToUgW3dBIWRYbaqoI7dAYiID0TOP5y5fqy14Ift+TQCSdNl0cvcHQOnXCy89UqeUdvXwQseiSw9hBVrrEURYgjq3RORK62fm+uFkY0cuisFEUAFkKuodqW8CpXLg682ncoh1yNqlRDEVQ5apRDJ4V+AXOHjn9Wcihc7ENnJYdO/KxDFkUYNRY2c+gMGgsDYQRd4PuJWtBJFc+AvYKOh4TNmnIbEaoPnVmVq5hDR0URBFEvIEGXKpg1FpabsQLmooyHXTd/FdzCJKrRX2YhV0HQ+WuBg78p7tnygJC0zaHjJ/Zq/WXZAf0sV+4kZTdR8gm5GDP6nPjamU9zF+WiCL4twJ6iCHFCghpyjdahMxE/unUYhVyFogh/HVASyOUyDLm6lOpX/l1ZyqEzyLE0bFsiznINk0NnWhQRIuTKj7NIQq6VR4VjwWC0ma0OXeD4qThsPAHFiFCTIuTiHvVvBIVcCaK+QYIuVVATwaW2JS53aDdEpHGnQJ8uFjy83NLoL8mhE/ebZpBDBwROutKgcLuqXNWiCCnvrPKIEH4WcuiymwYuuUMXoihC3K5dDp1ZUYTsTAHRzXI1en7IWa4mOXQAcGSbcmkUcs1qFGhlEkkOnYWiCNMqVyuNhSN16CwKuj0rgcc7AwvuDazLKIfOxj50orgy6+MoExRyNXHoxCKltAytZx+FXAmiXkCCLlVQc4u4KBLmX7okQRcybGpQ4Xh0R+AE59K3+Ah6rZhDJzcWFnPoJFHkk0RoyCrXGIoixBMWb6+RJuTQcSHHw4hGn5O4dlmAuq04dJEURQhulpwPGG2Vq86Rcxk3aTYSdLKbdWSrcmkk6Ph7N2wsbOBgAdaLIgxnuYYIuRqFpu1sW3JgnfJ97VujrQuQGgvHIeQKRCDoQlW5Cu+Tf55AIOQa+E4o5EoQ9QISdKmC3FhYzKFzS1+jlTw4UdCtfV+57DQiOPldt91QVa6CA+Ny6YsLZEFn5NDxE21EbUukalpR0BXvCqwrE2g3WBFx3cco94Vy6ORwsVjUoXPoTKZv8HFVltqW1Gn3yyFXK6PYjBCFjZE7Bxg3FpYdusoQVa7yfXWVwe9JFnSig6s6dEYhV4PGwqbj2Wq0z8tQ0EkilbHIGwvzY4tfhsyhs6GxsOjQWa10DcqhM+lDx9+Dy638sKOQK0HUKwwypglH4pYcHL+QQyc7dEZCxWw7jAFr3lWu9xsfeg26HDpJSBqNZ/LX6vOcZGcKUMRAXbU9bUt8gqCrE3LoWhwH/HWrFhprFJjnmtcyeJui8+L36V0Xw5CrJOhCOnSSkyOKH7ktTdR96MTvyEzQGVW5lho/V24sDAQ7dIAinjILjAUPYM2h01W51pnndYYNuRpMsACU7Ynfp98f/GNIRg7nx7ttibjmUouFESHblojzgaVjikKuBFGvIEGXKnjMQq4GOXQhCxukk/nuZcCRLcof9x7nhl6D7NDpQq6SI+VJB2ph4tBJJ76qkhjblhiEXNV1BU5eXMwBQO9xijvRbnDw891uKEPLmbJu8WRplkPHmLb9SNqWWCqKiGFShDwFg2OYQxdwdTIKgOpj2v1yY2FAc+jSMpRt+euU12cWRJhDZ9Ghs1QUIbxvo2ININiJYn6EDVLIDp3PIKQcjz50QPQ5dOIPG6McOv75UciVIOoVFHJNFWQHx6htCceovxpHztXi7lyv80LnzwHBVa5qtWKm+QxRv+CiyP3XOFXHYpsUUWcQclWfYxJW7XGOJkyMHudrD+fQ+ar1DkdIh04aueUPJeiiDLmKDp1Zy5NQVa6FbfXPNQy5Bt67yxVcUWom6DLzlTYnmQWaMxSUQycLOjOHTigQUh064fgzy6ELEnQWwq5qOL9KWxcQH0Hn9+nFmNWQq5xDJ2+T45McOjXkSg4dQdQHyKFLFUK2LYnEoRNy6BgDfv1Yud33kvBr0DUWTlOmLpx+H5BTFGI/gosCpuxTPpFWFccWcrXi0EWCO01Zs79Ov1a35EimZSon+orDihj2CaOojBw6s6IIlydYsNvRWNg05Crl8jGmhenyWwO//6K9ngs2I0HH768q1tww0xy6DODq+Vr+FmA8d1Z0kNXWMyZVrnU1xtXZZm1LZCfKSmGEKrClHDpPHASdLECtNhcOJUyNHDou+mmWK0HUK0jQpQpBo79COHQhc+iEKle/Txtd1bJf+DXIjYUBYNgd4fcT1AvLJkGXJhV4+IwcumgEHRfPdeYOHe9nV7JHEXSN2mt5e4DFtiWC+LHLoYsm5FpbqYmCgjba87IaaaFkoxw68X7eKsNM0AFAiz7SWtOUz9Tox4luUoSZoKsEwPT36dYkCST5thWHTs7PjKdDJzuIVpsLhxKm4v89WfxSY2GCqFdQyDVVMM2h80RX5SqGq8T7QyGP/gq5XoNu/kCgYa9NIdegtiVVwc8JJW5Ntyv0QtPl0EnCmYcjeWGEeGI0bInCHTq5KCJUyDUeRRFS6xrVyXIB+a2054khaVOHTmpdYtZY2Ay5FU52E2UddZVac2OzHDpRoFlpWyILJksOnRTO5z+oxGMhXoIu2qII3WNilasccg18ThRyJYh6AQm6JPP95kP4z5q9+L3EQIyIyI2FQ+bQhRJ0YsuHCAWdePKV92m2Xnk//jqtQpdTdSxGh46fdA0660fl0AkOlplDBwT3ohMLIsQiDPn1cnFIyCrXWBy6MIKOn+x5uDUjT6tqBbSCCCCEQye1CAnl0BmRJuVlZuQBzXoG1hXI6zOrchUFW5pRyDVcDp0FASYLbKPvxa7Gwjz0yT+78kPaD7hQWM2hCwq5Zun3SxBESkOCLsk89sVvuPndVfhlz7HQT5SHxvOeV5FMigCklg+1wfeHQj75hsIjiAY55Gro0EUj6ALvkztzdjl04mdt1ocO0ARPpeTQme0zKIculEMXxxw69bsJrIMLJ2+uUrTAEcWd262939zm2v1WiyKsrJf/SGhzov45pg6dkCMn7s+sD50sXMwEmJiLqVa3VivHgpFzalcfOi4481oFPgsGlB8I/7pIc+go5EoQ9RISdEnGm6Z8BbW+ML/u5QkPoXLoQokAXcPfGu0+I0cpaA02OHTMIIeu4rAmYCKqcg28z9oqbV9mz4kEUYzqiiJMHLryQ4F1hGhZAgS3LRGLIsxCrlacUxFdlWs0Dl2h9rzsRrqXYdwLwNlPKvmCHB6KDSqKCHN8qGuUCm0AoM0g/XPMqlzFbYjHr2nI1UJRxMGNwKPtgYX3K7fFHyM+cRyZ+H/B5pBrRq4mmq1UuoZ06Iz60AXWTiFXgqhXUFFEkkn3KCeD6rowJwOztiXiQHOOpUkRgtCyKhoicujE/YgOnT/YUSgRTlpmYsgI7oTxYgTZoUvLtCZUZYxCrrI7B2jiR512Ec6hk9uWhGosHK1DF03IlfegywMyC7XniSFXAOh+VvC2ghy6CHPojI6pNgP1zwmaFCFtWz5+uVDxVSvHHv8cZOFi5GztX6scTzt/DGxD+JFQV6WJInFNtlW5Cj8I0jKA0r3WKl3D5dDxPony9BHqQ0cQ9Qpy6JIMF3S1vjDhmlBtSyKpchUT/tWxSRbCrUBkDp3Y8T8oh05wFwGgZK+2zUhyxlSHjgu6GuPHI0V0MUUXTSYjX7nkDpfVkKvcviVefejCFUUYOXRmIVczgooiIg25GhxTTbtpny0Q3qFLkwWdOMHCoEcgx0gIiSFW8ZI/lgiHLj1Lm2JipdI1XHEHX5d8TPF+gHVV1mfbEgThWEjQJRkecq0J69BJJ2FRFAVVuVrsQxexQxdNlatByJULGS4YeDWjNzcyR03OATJy6KLBY9GhU8ONXNCFC7kK2xA/E6O2JXJFouW1R9C2BExxTHkOXYaUQ2fWeFlEbltiNEkhFEYOndsNtB4gPMckh87sdppXE7OioAvKoQsh6PiPA7nth5FzancfOm+OEHK14NDx92H2/5j/zZBz6LzCcUrzXAki5SFBl2S8Hqs5dCYOndvAoQs1KULnPhkMNreyBsBCDp3BAHUg0IcusHYe0uMOXSQFEYBW/KEWRQROWDxsGE1TYUAKuZrMJgUEQRcQRJYdOugFncutD7n6/cJIqzg2Fub7Ux26fMmhsyDobM2hE17TdpDxcwDzqSQiRnl0VtqWyEUp4vfkq46zQ8ePn2ztR4FRoY8M/8zNjrugHwmBYyQtE8qYO1DYlSDqASTokozlogjT0V+u6Ga5ikIrmpBr2Bw6oeO/mUPHHSD+nhp3tLYODheutRVKCJOfsPj4qlDCNhS6KtdQDp0ccrVYFAHow8M6h65GH+aLafSXmaAT7vfXaflvGXnK/vjnZiXkGnMOnUkYn+fRebzBbrBRUUS4dQEGbUsM0hyCZreKOXTVYapcYxV0AfGZni1M87DStiTwmZsd76pDJ/1IcLmEaRFUGEEQqQ4VRSSZdI/yCzlsUQQ/OTN/oLCAty3xBJ88Q+bQGQitaEKukVS5+mWHLnACatFXcee8uUD/8cDxV1hbB0d04MSTbUE7YP/PNjl0QnsYGTOHzsxV0zl0gmjTCbo6vSsTS8jVTFSJ9/vr9Dl0gFLFenCDvprVjJhz6ERHUXhN25OA3BZA404Gr5EdOoPj14pDFzLkynPoEhlyDazPm619Fla2yd+H2f97/v+Nr108RtKzFCFJIVeCSHlI0CWZ9EhDroB+gkHEjYVjqHL1GOQ7meEOEXJVHbomwF9+sbZvI0QnrK5SOwnH6tCJOXRyAYdIpplDF6bKFdD3OnNLs1z5Y+LcU6voHDqT71Un6Hza+rmr9afZSl5jYbvw+5OFU8SNhU1c38x84La1xp970JxYi4JOzqELFXJViyLEkGuNiUPHGwtH0YfO7wf2LAda9tc7vNE4dKaCLrANNYwvTtXIBipAIVeCqAdQyDXJRBxyBQKhQLFtSQSjv4xmrFoNuXIBZSQiZUTHyawPndU8q1D74OuordROwk27KZc5TaPbruWQq1wUIeRAGSF+ZqLI1fWhqzF2gazisRJydUPNnTJy6Jp0BjoOt7Y/b+A1Vma5hluvUeqA0XtwuaT3GUrQiSFXSbRYKoqQ2pYYubCxOHTfPwe8dgbw08uaoPPmBBdBhUINuZocL2rI1eC4SjcQvgRBpCRROXS7du2Cy+VCmzbKIO+ffvoJs2fPRq9evXDdddfZusD6Di+KCFvlKp7YfDWh25bEq8o1pwkw5BbFPYm2ylV06IxEUqSkZykn7Sph0kbvC5TPq+OI6LYZaVFEXZUiAMIWRYhVrtyhcyn360Ku3EmJMH8OsBZy5Y/5ayVBl2/+fDPMZrladRYjCeOLeLyhj1+j8V9yHzorbUvEXMc60aGzoSiCMWDV28r1/T9rr0/P0sSXlXYi4Yoi1N6GBp+X2ouOQq4EkepEdUa99NJLsWjRIgDA/v37ccYZZ+Cnn37CPffcg2nTptm6wPqO5T50ct6Trm2JcCIM10zXI4T21BOiRYcOAM58EBh+Z/jn6fYjhlyFWa6xOnSA5jaIgs6bA5xwpbUcMCPEtYdy6Lg7BSiisrJYuS5Wispw0cJPrvx71YVcY3DorBRFiPs1cugiwc7RX5EcD+J7s5xDZ8WhE6rIZXfZZ3MO3YF1wOHNyvXyA1LIVWpCHQoWzqELPG7UCkedFkGCjiBSnagE3S+//IJBg5S2Au+//z6OO+44fP/993jnnXcwa9YsO9dX71H70IULubpc+nCpWduScCLAKLct0vFSVtDNjDWpco3EkTGDhze5mAJifz9iU+RQOXSeNG3/Vce0ma6h+rdx0aKOXfPo1+wzcYGsonPoLAg6n9i2JIKxaxzRpfTV2VcUEQ53FIIuqA9diCpXQJs0wRELb9JtEHTrPtWulx3U96GTx8SFwiyHTt6GKkYNPnNqLEwQKU9Ugq62thYZGcqJ46uvvsJ5550HAOjRowf27bMwe5BQSbcacgX0Lo7qHEltS8INozfKbYuLoDMLufrty6EDtBNrVXFgvxmhHUorGI7+MlmrmEdXERB0ofq38e1wt4TvyyOIyEQ4dB7hRB6u3UoodFMZSmMriog05KpuI1TItVS7z0rIVSxWqas2aFtio0MnCrryg/qQfTQ5dPL/fS5q5bYlRu2HrOyHIAhHE5Wg6927N1588UV8++23WLhwIc46S5nxuHfvXjRp0sTWBdZ3eNuSsEURgF6MmeXQhXN1dP3Oogi5WkUsLBBdDrsdOn5i5Q5dNK6WjC7kGqJtCaDvRccdulD929xyyJVPRzCoco3KoYsi5MpFSrgfA0bopjJURC7W4xVyzTDKoYsg5AoECzo7Gwsf+A04+Jt2u1xw6NKFogijNcpwMSb/AOACXW6WLD4vEuFIEISjiUrQPfbYY3jppZcwcuRIjB8/Hv369QMA/Pvf/1ZDsYQ1MqxWuQLCH1+pbYmYbB+uVQc/+elmuSYw5Crm/9ni0AkhT8AeQWdYFGEm6ASHrvKoct1SyJW3JjEKuRr0C7NKpCFXf11sAlJ8na/avrYl4dAJV6PGwiFCrmooMkRRBGAQcjWpQI5G0G36UrnsfFrgtT6gZHdg7RG2LTHqQ+fxas6lmkNn0LaEQq4EUW+Iqsp15MiROHToEEpKStCokeZGXHfddcjOjiJs04CJKOQqVqiK1ZeROHS6tiXxDLkaOIFAoMo1RKFBpBiFXGNFzKELt1Yu6KqOaYLOUshVKooQQ66+GARWNEUR8ozPSOHHT11NbDl00YZcQ47+MpgUkZGrfF+h2pYAyvsRG0D7qk2qXHkfuggEHT9WinoCe1cpt/l9uj500hprK4Hdy4F2g/X9EgFJ0GUEu29G3zOFXAmi3hDVGbWyshLV1dWqmNuxYweeffZZbNiwAc2aNbN1gfUdVdCFq3IFzKsvI8qhM2pbEoeQq5ETCNjbhw7QHMl4hVz9YcLDXNCV7Na+EysOnaWQazR96Ky2LRGEJW9rEc3+AO0zr6vSthWVQxfB70uxLYqVtiXi7GJenRyqsTAQeD91+tuqQyf8P1MduggaC4s9IHOkv5m6KldJaH37FPDGucCa2dp9vGpcXFNaCEFn9JmTQ0cQKU9Ugu7888/Hm2++CQAoLi7GSSedhKeeegrjxo3DCy+8YOsC6ztqlWudhT+oorsmCo1IqlwNZ7kmMuRqd5Wr5NDZHnIN59AFcuiObg+sJyf0GkyLIgxCronIoRNDkjGHXGuiyKGzIeRqZVKE2JaD59eFq3IV3T2+LX48xJpDJ7rjuZKgE0d/yUKrZK9yeWyPdp/q0An/93WCTpp+YVSIQg4dQaQ8UQm6lStXYtiwYQCADz/8EM2bN8eOHTvw5ptv4p///KetC6zvWO5DB+hFktq2xKAPnZVt6Ga5JrAowm+zQxfPHLpwkyIAbfzX0R3KZSh3DhCcsVr9dnVVrjE4dG53cG87w+cZCbooHTouyuqiyaETQ64R/DmyPCki8P7U/Dm35mKHK4qolgSd2Osw1hw6UdDlFOkfC+XQyflwgPY+PF5tLWkZweHUkA4dCTqCSHWiEnQVFRXIy1PCFgsWLMCFF14It9uNk08+GTt27LB1gfUdb1oEVa6GbUukMVzhBtIb9qGLY8hVzqGLe5VrlKJERBS9oSZFAFrItThw3IeqcAWExsKSQ2dXY2FAE1ghHTpemRoQPNHMjeVwURZNUYTVEHHQ68QqVwMRz4U+d+bU1iw51osixJYngCTojBy6KEOuskOXnq1tU16jPJdVvM+dpv2/S8sUjqnANkLl0FmppiUIwtFEJei6dOmCTz75BLt27cKXX36JM888EwBw4MAB5OdHMT6oAeP1KH9QrRVFGCXrS7Ncwzp0MYz+igRPohy6gNuiFkXY8F4MQ64mve24oDsWqFAMJ+j4d6WGXEM1Fo7yvfDXhRR0gf3ysGIsQtguhy6S40HXWNjgffL7eK6iKuiyQosYUShVy4KuJLBtqddhzA6dMHPY5TbOf+Oogk76P8Vfy48jjzd4G0YhV8qhI4h6Q1SC7r777sOUKVPQoUMHDBo0CIMHDwaguHXHH3+8rQus7/A+dGEnRQB6F0f8Ix5RDl2Cq1yNRn/ZWeUaD4dODBf7BeFsBBd0/KQZNuQa+Pzl0V92hVwBTWBFEnKNJVTNXyv2eUukQ2e0dr5dLmL42rzZYRy6ECHX6oCgk13wmASdVBSRnqOfCiOLTmYQclV/IKVpn0tapj51ADAJuVIOHUHUF6KKsVx00UU45ZRTsG/fPrUHHQCcfvrpuOCCC2xbXEPAG0kfOl0OneByRVPlqutDl8iQq92TIvhwcS5MbBCnHiOHLkxRBCdUyxLAoG2JzY2FAcGlsSDouHMVS7sXvk4xHy+RkyKMfpColbeyQ5cdu0MnC+2oBJ1QkCSGXL2BUHHYHDqpchwI/C3ggs6rhYD9dcp1w5Ar5dARRH0hyqQZoEWLFmjRogV271ZCTW3atKGmwlEQ2egvE6EhnjzD9qEzmhQRB4fOqN8dEIcqV0nA2uLQCWGosDl0kqCzXBQR+EyCGgvbkEPHRW3ItiU2OnRcIIiVpJYdOkF0Rt1Y2CjkKvygAPQiWe0bF2GVq1nhTcwhV9GhCxzPPDRvGnK1kEPH7/f7AtdZ8Pop5EoQ9YaoYl5+vx/Tpk1DQUEB2rdvj/bt26OwsBAPPvgg/P4I/qgRgkNnpcpVOOmbti1x2CzX2kqoJxIgDn3oJNFjZ2NhSw5dnv62VYdOLooQ3deYHTorRRE25tBxARmNQxd125IwRRFpUshVnL5hOeRqUhQR5NCFEIhmiCHXXKHKNT1QnWsmtIyqXMW/BWrIVcrD4++fP8ahkCtB1BuicujuuecevPbaa3j00UcxdOhQAMB3332HqVOnoqqqCv/3f/9n6yLrM17etsRSUYTgrpm2LYlklmsCQq7iSR7QV47GxaFLsqAL69Dxogg55Cr0DIvVocttBhz4NbhhrQj/zmtsCFV7Ygm5RjspIlxRRGC7zB/IS+Rjr4R2HuFCrrJDp4b1bQ65im1LgkKuZlWutcH3uT1CuD1De61feP/8MXXtIcQtQRApRVSC7o033sCrr76K8847T72vb9++aN26NW666SYSdBGQHnDoqiOd5aprW+IC4ALAosyhi4dDZ9DnDAiEfwQxGitxEXSCa2F1UgTHatuSoNFfBiHXaL+Xsc8B+38G2pxo/pygkGssDp0ccnVZ/26jLooQGwuHcOiAwExW0fUMOGqRFkWo27azKMKrHMPePKVNCj+ezRr+8n3IealAQNAJRRH8PYs/Etzp+u+GcugIot4Q1Rn1yJEj6NGjR9D9PXr0wJEjR2JeVEOCV7nW+vxg4UI2YriUSdWXXISEOzEnbJYrD7lKgs72PnTxdOjEubNh2pZwwoVc1SrXwMlWbSwshFx5xW5WodUV62nUHuh5rvmaxXXYEnKVHLpIhJlR+M8KOofO4PgV76sTZrB6vNEXRXBszaELvA8edg0KuUaaQycURYh96MzmA5tV0yaLb54E5t+V7FUQREoSlaDr168f/vWvfwXd/69//Qt9+/aNeVENiYxAHzrGAJ8/jKAza1sCaOIooj50CQi5yic5v91VrgnKoQvXWJgTaVGE2lhYcF8rDgW21RRxQ82hi0NRRLROW9RVrgbHrzsNqhOn6+2XYd60lz+XYyrobA65Alp4XA25moRCDQWdmEMnNhYWc+hMfrzFmkN3cCOw7t/RvdaIxY8CS18ESvfbt02CaCBEFXJ9/PHHcc455+Crr75Se9D98MMP2LVrF+bNm2frAus76Wmai1Lj8yPNE0JjG47+Ehw6H8JPitDl0CWgylXG9hy6bP3tROfQedKVNXAxY0fItfygcl0eCWUnqkNnR9sSKV8yEkHHBbEnI7IQvE7QGazd5VKOhbqqwLEu9PbjYirox4ZP71TJkyI4dle5AoJDx6tcTZwzw6III4fOpChCFqNmwtEqn9wA7FkB3PgD0LxXdNvg+P3C3Nma0M8lCCKIqBy6ESNGYOPGjbjgggtQXFyM4uJiXHjhhfj111/x1ltv2b3Gek26IOBq68I5dKLQiNGhAxNyteLo0MnEu8o1bjl0If6rcFHicgOZhWG2HdiOWuXK25YI7mtFIG0hIYLORodOFXQRfK/ZjYGzHgXGPhvZPkXRaHasqRMsavQOlRpylQSYmD8HaDl0PAzKkfM2Y3LoAt97jhxyNXHOjBw6tbWOOClCKP4Q0yvk4pdYc+j4j4+Kw9G9XkRcg/xdEAQRlqj70LVq1Sqo+GHNmjV47bXX8PLLL8e8sIZCmtsFl0sJuVb7fABCiCvRoZOFBhcKVnPoAC1/Kp6TImTi3ocuXjl0IdaakQeU/a6IuXAuk5lDp3O1GABX+PBtLDglhw4ATr4x8n3qiiJMjt80L1CN4KIIs8pO2RXin01Grj4XNB4OXZdRwNr3gY7DlNuRNBbWTYrgIdcM4UeCL4RDF2MfOh/vdWdDUYXf4D0RBGGZqAUdYQ8ulwvpHjdq6vzhe9GJOXRyKJCfpKxWuQJCuC2ORREyzOYq12T3oQM0hy5cuBUwaCzMiyKkzyu7sT0Opuk6ZIcuhmNArnKNVNBFQ7hJEQB0M2atFEXIrhAXQVywc0xz6KLpQxdYe49zgLt3af8nzIRWqNFfLo/2uqCQq1kOXYwOHV+HHQJMJ1LJoSOISLHhjErEiuVedKFy6MR2BVa2AWgn87iEXBPl0Mk5dHZOihBC26HEFRd0Vhw1tbGwnEMnfV7xLIgQ9yvmlkWL2nMwkYIuTJUroInUoKIIiw4dRy58MW0sHEPIFZDaiYQrijDqQ5cGdD5VcYrbnaw/js2qXNUCkSgFHRdedggwcQ3URoUgIoYEnQPg0yJqwvWiMxJ0/OR08o1Az7FAszCJyW6P9kech5HiUhQRQtDFs8rVjlmuYv5SuLYlgDb+K1zLEiBYSMmzXDnxzJ8T18GJJVStOnRR5NBFiyWHLnB/nRRy5cIpyKEzEXTeXP3teIRcZcz60IXMofMAJ14N3LUdaD1AOI5DNKuOOeTKBZ0dIVcSdAQRCxH9lL7wwgtDPl5cXBzLWhosvBdd2HmuYsiV/8HnJ5NT/mJ9h+507QQHJDaHLu596Gye5eq3kkMXEHRWHLqgoog07X6XR/tschLk0HFiqnINfObR5tBFgxWHTpznqoYcM8wFmFkifpBDF2NRBGPhBZ1pDp1BY2H5BxL/8SEex+FCrtH2obNT0Imfv48EHUFESkR/eQsKCsI+fuWVV8a0oIYIr3StDevQCU2BPfyPdhSiyOOVBF0cQq5uj16gcOx26Hhln50tWCLNocsM/L/IbhJ+22pRRK3+NqB8D3WJEnTSZx9TlSt3wuJYNR20T2EfpkURfJ5rDYyLImRBVw1D7HboRPFj9lmJQosxTaQZhlxNfiCpPwDFtiUmjYWjEWSMCW1G7C6KIEFHEJESkaCbOXNmvNbRoFFDrpYdujrh13gUUXOP7M7EwaED9AKFoxNJNoXm0rOEtgxxyqEL9Tn3vxQ4ug3oN97Ctrmgk0KugPI98BNvwkOuNlS5mm07HsSlKMIsh04WdDE2Fhb3Y+rQCccF8weHYA1DrtLnrsuhE2bZGu0nGgFld4hUDPtSUQRBRAxVuToAtSgiXJWrmEPH/1hHJei8oW/bhShQOEycFGFTCmdaFoBjgetxcuhCuYkt+wKXzrG2bbOiCPm6FbcvFmRnyA6HjpPwHDqTtUdcFGEiItKz9W5zrA5dpIJO/AEnVrly504tipAdOsENVgWtmaCLIuRq1Nw4FowKPQiCsAwVRTgA7tCFDbnq2pYExF80gk5OwI9XiMxou3ZXuQL6wghbHDrhJGcl5BrNttU+dFLIlZOKRRFm244H6mflMheQokMnOlSROnQer/49xuzQceESYu3iZ2jmhPHr/nAOnU8vaA2fE4WAsrvNCPWhI4iYIEHnAHgOXXXYtiU8h85iOw3T7ciCLk4OnVGlq92TIgB9krrdfejM8pOixSWHXE0mHsRd0Mk5dLGEXE0qJ+MJP7Y8XvMKZCOHTiyKsNq2RBZ0cmW1KvaZtV50Yr6n2dpNBZ2wZrkHnPyjwyOkaJi1LYmlytUojy8WaFIEQcQECToHwKtcI3PoYshDkwWdWYuRWDESinbPcgX0zZRtnRQhfs4h2pZEtG3pPYsnYfEknugqV1tDrgnMoQu1bl0OnVAUEGmVqydd/0PBzKEDIhd0ZugEnc/4OhepZj/udI2FhRxCEbP2KFawu4jBZ3NOHkE0MEjQOQBvmvJHNXyVq+A4WJkxGm476u14CTqDE7sYxrTLoYuboLOYQxfRtk1OukByQ64xtS0xycuKJ/yzCnXsqv9fqvUiynSWa+A5clWrx6vPzQzKoRPEvpWwq1FTYRnx/7VO0Bm4WGJjYRFdHzqTBtJ25dDZ4ahRlStBxAQJOgfgtdqHThdyjUFo6BLx0+1zn2TMHDqOXQ6deJKyRdDFMYcuqLWEVOXKn5NZaM/+zEh1h66gjbKfRh3Mn6OGXCVBE25ShJGgs+zQWRF0Fhw6l8vYPWOhQq5mDp3PQsg11hw6aixMEMmGqlwdgOU+dLqQq00OXbzy5wBjB6JO6PVlV5VreiJy6GwuipD3JV7PbmLfZ2N1HamWQ5fbDJj0U+hmzoZFERZmuWbkAmXidtJD/2iIh6ADlM/R5xOKH/z67fNKV9O2JWIfOpOQayyNhe3OofNRDh1BxAIJOgfAq1zDF0UIbUtiCrmmG1+3G6PcPDFM49gcOuFEaHfPPDMXBdC+i3iHW4Hg7yaWdi/JqHIFgCadQz9uWhQRxqELmgyRIYVcTSZFAPaFXIGAoKvWxJaRABX3ZyWHznT0VzQOndi2hEKuBJFsKOTqANKt9qGzq22JlbFJdqDbttTpHrCxyjVT258d4eNIGwtHtG1pO+J2+eeVE+cedIC9jYWT0YfOCkaNha3Mcg0bck2UQycJTyMBGur/k9g0WHQozZ4TKbY3FqaQK0HEAgk6BxD56K8Y25a4EyXohP1wFy2eDp0dPegA/WfK3RTbiiJMeoWJ1xPi0KX4pAgrpIlFEULI0XT0Fw+5Sg6dJ11y6OzKoQvn0EliSxY5olMPmLu/vjqgtkK5LruL1FiYIOoNJOgcQEbEo79qY0vW1+XQxTHkqpu3GTgJ6nLobBZ0dolTUZCoM1dtKhwJWRQR+Lyy49yyRN4vEFuo2p1m3n4lmRjm0GWGaFsSqsrVzhw6HnK1kEMHhBB0skMnVy4LqQPVgaRAeYyZXX3obJnlSg4dQcQCCToHYLkPnWEOXTR96Eya2dqNuO30bOVSPAnYVuVqt0MnCrqAAE1EUYQack2CQxdLMYnLpX99vPoaRgr/PKuFCoeQRREBQZeeFRwK1x3LsebQRVAUAWj/140EqPgeQuXQ1QQ+A1msOrXKlYoiCCJiSNA5AB5yrYlE0MXStiRRVa6iaODd9cUwjW1VroFt21EQAZg4dHEqihBv57VQLsMl+9uBnW1LAH1I0ik5dHxN1SXafSGLIgTnTBSonnT95yOL30gbC9dZDLnKbUsiDrkKr1cdOimc7KjGwjT6iyBiwSGxkYaNN6qQawzJ+u4EVbl6DCoDuaCzSyCJ246HoKuz26GTtiOKn9PvB7qfDXQ61Z59hVyHjTl0gOTQOeTPCl9TjeDQeSw4dLyRcF2lth2+LY/XoLAl0sbC0RZFGIVc+XtwGRxbokNXqlwPcujsyqGzu8qVHDqCiBSH/OVt2FgvihBDrrHk0CWhylV26Ox0cdLtFnRuKFW5zP71hsqhyyoEup5hz37CIU/xiFXYpzlQ0PE1VQfEjDtd+W5NZ7kK7UR0Dp0wy9VM+LrcipiLS8iVO3QhqlyNPnPx9eFy6JzWh45y6AgiYijk6gC8ltuWGIykcnIfOlE0pEmCzk6HTi2KsEnQAUKFIA+5JiCHLpG4pe8m1qIPJwo6NYcuIOj4MRhu9JdcBCGGXM1+NJgVWhgRSR86QBNbRg5dqGp37sTXVGiOV6rk0JGgI4iIIUHnACyHXHU5dDG0LUnYpAiDRHK724AAQKsTgIx8oONw+7apCjoeck1A25JEohN0NghhXcjVKTl0gTVVBXLoeE5duCpXeXarWBQht/3gRCToIg25xujQVRVr95mGXGPMobN7lqsdVbME0cBwyE/pho3logi72pYYVVbGA10OndS2xE6HrmkX4K/bgsOIsRDk0MWpbYmdn0Mk6I4BGwSdrijCIX9W+PEn5sIBFooi5JCrMPrLFocuSkFnlPOnpl4YOXSB+3gOYVpW8P8R1QX0KwUdkRzntvehI4eOIGKBHDoHEHHbEuaPrfoyUX3odFWuskNn86Fnp5gDtJOh7UURIXLoEokcco0VRxZFSIKJi06rRRHidvjtUDl0QHxCrqZFEbWCQ2ck6KTvQc6fk18XaR6cToDZkEOnC7lSUQRBRAoJOgdgvcpVbKcRQ7J+Uooi4ljlGg9Uh87uoogQVa6JRNyvHSFXJ+bQye+Li7Fws1xlhy5NqHJNqEMXTtCFyaGTBaMcbhX3YbT9cNAsV4JwFPVe0O3atQsjR45Er1690LdvX3zwwQfJXlIQ3kirXAGgrkq5jCYUmDBBJ06KkASdU/KszJAFXb0rihC/m3oq6ORj2xPOoRP60KVJLna4Klc+q9jO0V9BfeiizKHjGDl04g+rSEUU9aEjCEfhkL+88SMtLQ3PPvss+vfvj/3792PAgAE4++yzkZOTk+ylqagOXbgqV/EEFUsuWsL60ImzXAMnQrV/XqoJugQ0Fk4kthdFOLGxsOzQ8Rw63rYkRFFEUNuSwPGbHi7kaqGxcNSjvwwEaKiJMfL34M0zeE4sDp3dVa7C+6NJEQQRMfVe0LVs2RItW7YEALRo0QJNmzbFkSNHHCXo1KKISEKuseR2JaPK1WwouFPh66u3Dp3NOXQp4dBJgk520/j/qaDJEF6gyyilivqECcb7ckXj0EXYWNiwKCJU2xIrOXTCc6ysXbd/u2e5UsiVIGIh6SHXb775BmPHjkWrVq3gcrnwySefBD1nxowZ6NChAzIzM3HSSSfhp59+impfK1asgM/nQ9u2bWNctb1Ybizscml/gPnJJ6ocugRVuYpOYKj5l05E/ZxtDhEHtS2pJzl0TiyKCHLoIgi5eqSq3fyWwIT/AL3OM95XVDl0CepDxzHMoeNNtA22Hw7bq1xpUgRBxELSz6rl5eXo168fZsyYYfj4nDlzcPvtt+P+++/HypUr0a9fP4wePRoHDhxQn9O/f38cd9xxQf/27t2rPufIkSO48sor8fLLL8f9PUWK5aIIQPsjrebQxerQJSrkmmoOnRxytattiVOKIuxuWyK1+XAC8vuyXBQhhFg9XmvffVRVrpH2oQtV5RplDp3RfqxidyNgv81VswTRwEj6T+kxY8ZgzJgxpo8//fTT+POf/4yrrroKAPDiiy/i888/x+uvv467774bALB69eqQ+6iursa4ceNw9913Y8iQISGfV11drd4uKSkxfa6dWC6KAJSTZV2l9gvW0Tl0Bn3oOCmXQ1efQ652F0U45LuVj23LRRHpmptnVezGtco1VFFEjDl0fD/+OgdUuQr7pxw6goiYpDt0oaipqcGKFSswatQo9T63241Ro0bhhx9+sLQNxhgmTpyI0047DVdccUXI5z7yyCMoKChQ/yUqNJueZrEPHRAsABw9yzWVHTo5h64+F0XY0YfOgY2FTYsiLDh0XMhZ/cETl5CrtM54VLmKz4upKMKOWa6UQ0cQseBoQXfo0CH4fD40b95cd3/z5s2xf/9+S9tYsmQJ5syZg08++QT9+/dH//798fPPPxs+929/+xuOHTum/tu1a1fM78EK3KGrthJylU8CZn+krW4jUQ5dUA6d0wVdPXfodHN2bRD1KVEUwR26CEZ/Wf3BE5eQa5g+dHU12v6MGnVb6UMHCMIxhqIImuVKEEnHIX9548cpp5wCv8U/VBkZGcjIsHHAu0UsF0UA+nBpv/FAUY/Id5iwKlex15nkAtk9KcJu4lW8IAvZZH0ODaHK1eVSjm8u1NQcOjNBZzD6Ky6CzmLIVe5DZ1jlaoNDJ+/HKrbPciVBRxCx4OizatOmTeHxePD777/r7v/999/RokWLJK3KfnhRRG24PnQA0KQzABcwaiow7oXokvXdCQq5ukMIulRx6Di2OXQmszQTje196ByYQwcET3wAwodc0zK050Ycco2kD53V0V+hiiJC5NDJx2yoHDqj7YdDl0NHIVeCSDaOFnRerxcDBgzA119/rd7n9/vx9ddfY/DgwUlcmb3wkKvPz+DzhzkhjH8PuO1n4JS/RF95mZSQq+zQOeikb4S8PtsEnVzl6gBBZ3eVq1McOiB4JitgbZarJ9KQazz60MltSyJ06MQ2R0AccujsrnK12fEjiAZG0v/ylpWVYfPmzertbdu2YfXq1WjcuDHatWuH22+/HRMmTMCJJ56IQYMG4dlnn0V5ebla9VofSE/TTvK1Pj88ocSON1v5FwsJK4oQDq90ac0N1aFzSlGEuN/6WhQBROjQiVWufNRXEkOuQW1LDARdqD50gFbBCoTIoZOEo1XiWeVKbUsIImKS/pd3+fLlOPXUU9Xbt99+OwBgwoQJmDVrFi655BIcPHgQ9913H/bv34/+/fvjiy++CCqUSGXSPZrTVuPzIzM9zif5pEyKSDWHLl4hVzmHLllVrm7lPTF//Z3lChj/eLHi0KXFM4fOashVrnI1Crn69c8N2kY6gEDPSlOHjo9Ci1BE2T7LVRR05NARRKQk/S/vyJEjwcLknUyePBmTJ09O0IoSDw+5AhabC8eKLtyWgJCrO81AIKWYoItbUUQSPwd3OuCrjkNRhIO+W3FdclGEWCzFmCYidG1LkunQhcuhE0KuZv+fxO/C9hw6m9uW0OgvgogJR+fQNRRcLpfq0lmqdI2VRDl0/ETh8Ro4Uw4/9OKWQ+eQtiXivu1oW+LE0V+AFHINvE8j8SWKE086kBcousq1GAmIq6CTZrlyYWo15MqJZx86qnIliKTjoL+8DZt0jxu1Ph9q6yxUycVKoosiPOmp79DVt8bCgCDo6mnbEkAqigis0SjkKuaDebxAp1OBS98HWh1vbT9xDblKOXTpWcrov3Cjv+T7w+XQReqy2T7Ltc74OkEQlnDQX96GjTfNjYoaH2p8CUgGTlRRRNOuQLvByknRSaFGKyQshy6ZDl1gLba0LUnxoghZ0LndQLfR1vcT1z50UpVrejZQeVQa/WVyfKr/112AN8dkP9Hm0Ek5b4zFNvOYQq4EERMO+svbsOHNhWsS4dAlqg+dJx24+gvleuVR/WMp59DVs6IIQAiJ21EUIbh8ThJ0VtuWcNfM5Y7uO4nrpAgph45PXRH70Jk6dIH34s01F1t29KEDlPcey/9rWSASBBERDk9kajjwwoiahOfQxTHkKpJqDp1HLoqIU9sSJwg6W6pcU8Gh40URBqOurLpmZqh96Kw0FrY6y1XuQxcQPGlc0EWQQxdqRKAdOXTRvD7U9sihI4iIIUHnELRpEYkQdGKVaxwdOpF4OV7xokGEXG3MoXNsUYQ4rUSe5WoQco1a0CWgypUJOXSAUqFsNYfOLH9OfE7EfehqQ9+OFOpDRxAx4fCzasNBrXJNRNuSRFW5ijgp1GiFhlAU0aSTsv9GHWLflmOLIoR1eaQcOqMq12gda6uCzu/ThFNYQcdz2wyKIoDwo78ALb0ipENnwyzXaF4ftD2xKIJCrgQRKQ76y9uw4Q5ddUL60CWoylXESULGCnFz6Bwy+gtQxshVHAEKWse+rZQqijAoAkiUQye3RwmFXH0alEMnjv4K04cupENnMjkjHHIOXayuGoVcCSImyKFzCEW5ysnm95Kq+O8sUVWuIqnu0NXHxsLpWfaIOUAqinDQdyvm9qWFaluSIIdOrqYNRZCgkx06oco1bA6dSVNh3X5imOUKxF7IIO6f+azlIxIEoUKCzoAZM2agV69eGDhwYML22aaRMut019GK+O/M5QJa9gfyWwM5RfHfH9+n6HI53qGLV2NhQSi63LG1eXASqVAUIYdcU8ahk6tchbnIdVX655ptw0oOXcwOnY0hVzu2RxANDAf95XUOkyZNwqRJk1BSUoKCgoKE7LNNI+VX9+6jlQnZH679SvmDaUeFo1VcHu2E5yQXx4hEFEU4XdRGglOLInQOndS2BEzrnZYwQRfYj8sT/v+AS86h41WughvKBZ3ZseSxkkMXpUNndw6dUZFFolJCCKIeQA6dQ+AOXcIEnSddC90kCp2Ycfihl4iiCCcJn1hJywgIDVfij6tQGDp0wrHHXal4hVwrjwLfPg0U7wrsJwLhGDT6K7Bt8fOtrdA/N2gbFnLoZOFoBb8v+L3GMt1BnKWr7oMcOoKIhHp0RkltNIcuASHXZKETMw53p4IEnU2hUXc9FXQuFzDuBaC6BMgqTPZqNDwhcugATZT4qoOfHwlqHzpJ5Kx5D/j6AaBkD3DOU9abCgMh+tAJDl0tD7ma/ECKKIcugpCrLnTs1RdoRIORs0mCjiAioh6dUVIbLuh+L6lGdZ0PGWkOFzzRoMsfc/j7i1cRh+gO2dWs2Ckcd2GyVxCMUVGE+B1wsWRbyFVK5OcTUsoOSPux4ASa5dC50zQRFdahiySHLgIBJebPpWfFLuiM2pSQoCOIiKhnZ5TUpXGOF1npimjYW5yAStdkIAqYlHPo4pBDV58cOqcSqigC0Fwp7nRF22TZLORaF3D+qkuUy4hCrlJ/OHHMF38v4XLoGndSLou6hdhPFI2FRbHFizRiqXI1ei0JOoKICBJ0DsHlcqFtY8Wl23WknoZdXSlUEBA3QZdCLmV9gDt0Lrc2IUUXcg2ImLo4CTou4KpLA7cjyNWT+8OJLUr462sDObdmPw7OeBCYvALoMirEfqLIoVOLO9yaOI2lD53o0PH3Qs2FCSIiSNA5iIQXRiQadyrn0FFRRErCnSzRqTNy6LiTlm63QxcQilXROHQmjYXdHu31qqAzq3JNA5p2iWw/VuBiy50efZWsiLhvPquWHDqCiAgSdA6i3hdGyD3YnEzc+tClkKitD/C8Od1oMoOiiLqAMLI95Co7dNEIOmmWK8+hA8ILOiuEEmTLXwdmngNUFuvvF9+HHY4aD7m6PJqTSvNcCSIiHH5WbVgkvBddoknlKte4FEU4/DOoD3DhIwo6lwuAVJXKHbpo+zKahlzlHLoIQq4uOYdOLIrgIdcK/XOjIZRDt3wmsOM7YOcP+vv5WjzCWuwoivCIjh+FXAkiEkjQOQgt5FpfHbpUmhQRp7Yl4sQMp38G9YE0g5ArEDzPVc2hi7KHXriQa22F0qctFoeOr1XMWzu2W7nMaRrduoFg4SjCHcCacv39OocuylmwIqpYTddmTVPIlSAiggSdgyCHzkHEK4dO3Bbl0MUf7h6lSQJKnueqVrlG69CZ9KGrE9p71JRGV+XKt6mrcuWiJ+BitR4Q+Zrl/RgJKFWQSn+TDHPoYgm5CvmBagiXBB1BRAIJOgfBHboDpdWoqq2H+SMplUMXpypXQDuBkqCLP027KZ9zs576++V5rvGqcq0TWhBVlURY5WrWh86jF4TePOV9RkuokCsXcmaCzmOTo6bbXgiBSRCEKXRGcRCNstOR4/WgvMaHPcWV6FwUohloKpJKc0zjVRQBaCfQ+tZY2IkUtgPu2ABkFurvlx0626pcpcbCYgPe6igdulBFEQDQ+gR7iiKM+tCJIWMRv1HOWyxVrkLIVXYfCYKwBJ1RHITSi05x6bYdLA/z7BREF3J1+KEXr6IIgEKuiSanqVY5yVEdunhXuVZr16tLbJwUIby+zYmRr1e3Hws5dLKgM8qhiyVEKhZZ2CEQCaIB4vCzasOjT+sCAMCqXUeTvJI4kNJFEXY6dFQUkXTckgCLV5WrTtCVRjjLVRKdRkURANA6ToLOVyfkGMqCzkBc2hFydZOgI4hoIUHnMAa0bwQAWLGjPgo6QSRRUQQ5dMlEFWBxrnL1CYKuqiSykGtQ2xKTkGvMDp1JDl2dkDcXlENn0IfOrpArFUUQRFSQoHMYXNCt3lWMWp8/zLNTjJQa/SXn0NnUtkTcttNFbX1GLoqIuco1wSFXXrVb2A7IbRbdmoP2Iwm6WqGgQxZ0hjl0NjQW9qTb4/gRRAOEBJ3D6FyUi4KsdFTV+rF+X0myl2MvqTQlISE5dA7/DOozQUUR8apylUKudREIRytVrrGGWwHzPnSiQxfUh85I0MUyy9WgbQkVRRBERJCgcxhutwsntCsEACzfXs/CrjqHzuGHHrUtqd8EtS2J0yxXn+TQlR1QrudYcNXk6lOxyrWgjXK986nRrddoP7KgC+XQ2T7LVQy52tComCAaIA4/qyaHGTNmoFevXhg4cGBS9n9ih8YAgBU765mgE4sinO5OJULQOT3sXJ8JKoqItcrVrLGw5NCV7leu5zW3vkYubNQcOg8w4i7gmoVA/8uiW69uPxYcupBVrjbOchX72sWyPYJogJCgM2DSpElYt24dli1blpT9n9AuUBix/SiY3NcqldE1Fna4mAnKoaOiiHqFmUMXcw6d8P+VMb2gqyoBygKCLrdF+G2ahVxdHmWdbQfZ88NIdQIlMRoyh06c5WqDQ0dVrgQRMyToHEj/toXwuF3YX1KFvceqwr8gVUjp0V/xCLk6/DOoz8gh0nhUufrrAAgCr7oUKP1duW7JoTOZ5Wr3DwFThy5UyNWoytWOWa42tUEhiAYICToHkuX1oFfLfADAqvoUdk2pSRFUFFGvsX2Wq4Ggq5N+jFUeBcoDOXR5LS2sURJKouixEzNHTCfozIoiREFnwyxXGv1FEFFDgs6h9G2jNBj+ec+xJK/ERsihC2ybcuiSTiJmudbV6J9zZKvyuMsN5BRZXyOY0lyYCTl0dmJaFBGqD50YIqXGwgThBEjQORRV0O2uR4JO59A5/NALEnQ29qHj751y6JKH6NCJExHi6dDx/LmcImuiTHyOv05fFGEn8kQKjlHItbIY2P+LUMTgtcdRE91HKoogiKigM4pD6dO6EIDi0Pn9DG63jYIiWaRqHzq7nTTKoUs+XID5/fpqznQbc+jEliUiuRby5wD9Meivi1/I1awPXa1BleuHVwFb/gt0O0u57bFpsoMu5JoEh+73dcp+i7olbp8EYTMOt0kaLl2b5yIjzY3SqjrsOFIR/gWpQEpNihAFnc3/Tfi2SdAlD9GhEytRPXY6dDXGz7WSPwfoj0HmE2a5JijkKjp0/jrl/RzarNze+aNyaddkBzHk6rGhyCISjmwDXhoOzBgIvHwqsGlhYvZLEDZDgs6hpHvc6NVKKYxYu7s4uYuxi1R16OxeK7UtST78O2B+Tbh4vPpeiRFtz6APHd9ueo7+uVYqXAGDkGuCiyLkvLnaCqAqkAJSVRx4rV2NhY0aFSco5Lr9W21fe1cC86YkZr8EYTMk6BxM39b1LI8upfrQxdOho6KIpOMSmvbWxtiyRNyeLuQacOiym+ifa6UHHaA/Pvy+BOTQSY5YnRQyrilXpl2I6HLoYqlyDezbY1ORRSTs+km57HqmcllZjzoLEA0KEnQOpk+bQgDA2vpS6SoKI8c7dHEMD1NRRPLRhVxjbFkCGDcWVseJZQHeXO3+PIuCzu0WhGdd/KtcmSzoJIeu/AB0ffUASYDFMstVrHL16O+LN7uXK5fdRiuXNeX675EgUgQSdA6GV7r+uucYfP568AcmVatc4+XQOV3U1mfEtiXqlIgoW5YAJjl0fLteICNfu9+qoAP0vejiFnI1K4qQqnRL9gW/VteHzu6QawJy6KqOAQd/U653CszF9ddp7ipBpBAOP6s2bDoX5SIr3YPyGh+2HCxL9nJiJ1X70NnZsgSgxsJOQJzlyp2odJsEHRciPkEoZuRpz7UacgX0Faji6C87MS2KkBy6UgNBJwqwmGa5iqPEuOOXAIduzwoADGjUQfnHqSk3eQFBOBcSdA7G43ZhQHtlruvX6w8keTU2kKo5dPEKcTn9M6jP6Bw6G0Ou278FHm4F/PSKUGyRAWSKDp3FoghAL7a4+5ewogjJoSvdH/xaT7pNs1y5+5jgtiU83NpmoPL/nOdR1tSDH9BEg4MEncMZ00f5NT/vZ4Nfx6lGSlW5xjE8rIZcKYcuaag5dH57Q64H1ilCbts3WtuSNK/k0EUi6ALrFAsUEtZY2IJD57EpROpP0qQIXhDRZqBy6Q1UJFeToCNSDxJ0Dues3i3gdikNhnccTvEwgCiMnO5OuVzaGqkoov6hhkh9WnsOOwQdp6ZMCrkGHLrsplpI0QpqODOOgs60sbA86eL34NfGZZarDY2KrcAYsHuZcl0WdBRyJVIQEnQOp0luBoZ0bgoA+DzVXbpUcugAITRKRRH1jngVRXCqy7TtegSHLpKCCEBw6IQk/USFXOXRZUZFEbbNchVHfyXIoTu6Temn58kAmh+n3MerkSnkSqQgJOhSgHP6Kp3lP1+b6oIujpWj8SBeEx2oKCL52N62RCqcqSnTC8VMpWI9onAroB2DorhKtKDzeJVLHnLNbqo9x7ZZruKkiAQVRRTvVC4bd1TC4gA5dERKkwJnVWJ07xbwuF34dW8JtqZytWsqVbkCgkNnc5UrNRZOPmJjYXWigw2NhTnVYsjVC2QVKtfzW0W2XbUnm+DQxWu2MJNy6HjINauxcllxSLls1V97TlxmudogEK1Qsle5FEexkaAjUhgSdClA4xwvhnVVfhXPWb4ryauJgXg2640HqvCy+b9J25OUME/rAfZul7COrijCxipXTk2pEHLNAPpdCgy4Chg8KcJ1cocuEUURJm1Lshvr72/ZX7sej1mudjQqtgIXdPmttfsyKORKpC4k6FKE8YPaAQA+XL4bNXX+MM92KCnr0Nm81kF/Bv62G+g4zN7tEtbRzXKNVw6dIBQLWgNjnwWa9YxunXxbLk8cHOMwbUvk0WX5LbVeerbNcjXIoYv3pAhV0AmuqZpDRw4dkXqQoEsRTu/RDM3zM3C4vAZf/mrQDyoVSDmHLk5FEYCWs0MkB90sVxuqXPmweo6/FqguDWw3BudPFTeBkGs8fgiFayyc1Uh/f2YhcPKNQLvBQOsT7JnlysWbJ0qBuHc1cGB9ZPvkOYH5RiFXcuiI1IMEnQEzZsxAr169MHDgwGQvRSXN48YlJ7YFAMxeutP0ebuPVuAXp85+TdUq11RYKxEZuqIIGxy6vauC76s4rFx6bBB0fI3xaHWjznL162eYqg6dFHLNyAdOuQ24+guleteOEKlfaCwcaaPi6jLg9bOA10frQ9PhKNmjXIohV8qhI1IYEnQGTJo0CevWrcOyZcuSvRQdfxzYFi4X8MPWw1i582jQ44wxXPbqUlzw/BLsOlKRhBWGQXTlUqLKNU45dETyMZwUEYOgO+4PymX7oUB6QBSUBwRdTA6d1Fg4HoJOPL65KGNMcOgkQccrdtU12hly9US+vdJ9ylqrjgH71ljfp2FRBOXQEakLnalSiDaNsnFePyXfY9I7K3G4TP9r9Lf9pdhxuAK1PoYfthxOxhJDk6oOHQm6+odbaCysVrnGIOj6XQpcNR+49H0tsb7CRkHHK2bjcSyKIpGLKHHUmOzQmQm6WHLedCHX9Mi2VyH8rdu11Npr6mqA8oPKdXLoiHoCnalSjAfHHYeOTXOw71gVbn1vNXx+LUTy3aZD6vXlO44kY3mhSaVZrgAJuvqM6tD57XHo3G6g/RBFzHklQeeJIV8ykSFXQBN0tcLYr3AOnRoitSnkGqlDF42g4/lzngy9YCVBR6QwdKZKMfIz0/Hi5QOQle7Bd5sP6Wa8frtZE3QrdgSHZKPF72eY9M5K3P7+ajAxxyZSRGFEDh2RTAxnucbgpIlwh64y8KMqJqEoC7o4FkUAimMJ6BsZBxVF2Bhy/eUj4IfnpcbCEQrEcu3vHnb9pM8DNEMsiBCrhinkSqQwdKZKQbq3yMP1IzoBAJ5fvAWMMVTV+rB0q/ZLdcvBchwtrzHbRERsO1yOz3/eh7kr92B/SVX4F5iRclWuNNGh3uIyCLmmxdBYWMQbGPPFQ5Z2hlzj4tAJxzcXUWLlrzdbeG56cAPmaGe5Mgb8+xbgy78BBzcq93nSIt+e6NCV/a5NgAiFUUEEoAm6ahJ0ROpBgi5FmTikA7K9HqzfV4LFGw9ixY6jqK7zo1leBjoVKWEDu1y6jftL1evr95VEv6GU7UNH/03qHWJRRK0NjYVF+NxWTiwhV5dcFBGH/ze6ooiAyyaGodMFQZdZENwHL9pZrtWlmhPGCzBiDbkCiksXDj6XViyIACjkSqQ0dKZKUQqzvbjsJKXZ8HNfbcK/VysVW6d0bYqB7ZWckBUGlbDRsOF3UdCVhnhmGFJ1lmsquIlEZBjOco0hNCrCQ64cO0Ou8TgWXa5gEcUduvSsYEEXtEZBHM+/C/jXIKDKwg+/ikPB98VSFMGFs5U8OqOmwkB8BV3lUeCja4Et/7V/2wQBEnQpzbXDOsHrcWP1rmJ1JNiwrk0xoL2S87Jiu00OnSDo1sXi0FGVK+EUdLNcA2IplipXEa8s6GwoilAbC8ch5Cpu19ChE0Ksmfkh1lgLrJ4NHNoA7FkRfp/lBpX47jS9QLQCz6HrOFy5tCTowoRc45FDt+Y94OcPgG+ftn/bBAESdClN8/xMPHJhH5zYvhGyvR60KsjEqd2bYUAHRdCt2V2M6rrY5yFusC3kKhxuqeB6UR+6+ouuKMKGSREitjp00uiveAk6lySi1FYuFhw6Psu1rhKoDvx9OLY7/D6NHDp3mjAbNkKHruto5fL3X8OLQaMpEUB8HTouNEv3hX4eQURJnP46EIniDwPa4A8D2sDvZ3C5AJfLhYKsdBTlZeBgaTVe/XYbJp3aJertV9X6sP2w1qR4+6FyVNb4kOWNQpClqkPnJkFX7zCc5WpTDp3Xxhy6oMbCcfp/45YqS8W8Qp1DZxRyNTiNWBF0vA+ciCddcE8jzKFrcRwAlxJGrzgM5DYzf40acpUduoCg89cqversHNHHc/tKU3R0I+F46ExVT3C7XXAFkpVdLhfuOqsHAODZrzbit/3Ru2pbD5bD52fIz0xD01wv/EyfUxfZIqkPHeEQdCFXm6tc5aIIO2a5xl3QcYeOh1y5a5mliRzAZkFn4tBFWxSR21zrKVd2wPz5fr/mkpkVRQD2hl2P7dbCvDVl2pxfADiyDXj3UmDz1/btj2iQ0JmqnvKHE1rjjF7NUetj+MucNaioiW4sD8+f69EiHz1bKvkzUYddU7bKNQXWSkSGWBRhe5VrHIoiEp1DVytMz/AIladWBV2JlZBrQIjlCYUJoqDzWfibVVulCa/sJkBOwJUzcv845QeV9+lyKyJQxJOuzd61U9DJlbfcpfP7gU9uAjZ8Dnz/T/v2RzRISNDVU1wuFx6+oA8a53ixfl8JrntzBapqI8+n425ctxa5sQs6VcS5glsfOBHKoau/2D3LVUQuirBzUkS8flyIAhfQO3SAlkcXD4euxznafZ4I25ZwUehOU9aW0zSw7RCCbu9K5bKwvdbEWIQLcjvz6IIEXcAhXPUWsPN75frhLfbtj2iQ0JmqHlOUl4FXrjwR2V5lqsSf31yOnUI+nBV4QUT35nno2VIJJcXs0KWCOwdoydmpsl7COjwvsq4KQGCygF1VrnaGXF3iOpEchw7Q8ugyC81fK3Jsd/iJDbwoolV/oOMIoElXILdFZEURXNBlN1F+JPK8uVAh141fKpddRhk/Ho/CCLXyNvBDtnQ/UHYQWPgP7TnHdulHrhFEhJCgq+cMaN8Ir08ciIw0N77ddAinPrUYf5v7M45VWqsg44KuW/M81aFbvuMoxk7/Du8HWqVYRnW8UkQgUQ5d/YUfg+JJO14OnR05dGrINd45dDY5dHVVQEWYedLcoctuClz5KTDpJ6UIgW+P+ZWQZCi4KMxuolyGC7kyBmxaoFzvNtr4OXa3LqmtBPavVa63O1m5LN0HrPsEqDoGND8OyAh8rke22bNPokFCZ6oGwMmdmuCjG4dgRLci+PwM7/60E2c9+w2WbDZIShbYdaQCe4qVP+zdmuehS1EuBnZoBMaAn/ccw18/XItf9hyzvpBUG6VFgq7+wo/BWsGxjiU0KhI0KSIGQcdFJm/UG/cqVxOHjrtWhoLOLf0fCbhQx8L84OOCLqdpoLmxW78WQAsBm8FFoyrowoRcD6xTihPSsoAOpxg/x26Hbu8q5XPNbQG0OVG5r3Q/cPA35XqXUUCTzsr1w5vt2SfRIKEzVQPhuNYFeOPqQXj/+sHo0CQb+45VYcLrP2HdXvPw6Qv/U3I6hnVtikY5XqR53PjghiFYcvdpOKOXkkz89MKN1hfhSjWHjnLo6i2qQxcQdGmZ9uV1ykURsQhFPsmA51zFPeQq9aHjgnLQn4HOpwHth5i8Pl273qyXchkqj44xzV3jIkxeCxB+WoQYcgXCh1x5uLXj8OCZtBwjQVd2UDtWIoWHW9sO0gpASvcDhwJ/O4u6A00CraWOBPLofLXhQ9YEIUFnqgbGoI6NMe/WYTi1exHq/Ax/+/hn+PzBfzj2Flfig0BI9ebTuuoea12Yhb+f3RMetwv//e2A9ZmxqkOXIocdOXT1F/6d1gZO2naFWwF9HzqPN7bjvaBN4Erg/2jcGwsbTIoAgAETgSs+DnYfOXxdOc2ApgFxEkrQ1ZRr+8gOIejCFUaUS6IwXMhVDbeeab5NHnLlrUUObwGe7QN8eFXotZixa5ly2fYkIK+Fcr10P3AwIOiadtM7dNu+BR5qBjzXD1h4X+h8QIIQoDNVAyTbm4ZH/9AXeRlpWLOrGG//uCPoOS/9bwtqfQwndWyMQR0bBz3esWkOLjpBOdn89cM1ePOH7ThSXhN6x6nWBkRtLJwi6yWs45Zy6OwUdKJDF0u4FQAK2+lvx7vKVW0szGe5Wvxc+P+VwnZAfkCEGrUuqasBqss0dy4tU9/7DdCKIoBgQVe6HygRJi0EOXRFyqWRoCs7oLllXUMJOsmh27RAySnc/FXkLh1jkkMX6Ht3aCNQFmhd0rSr5tAd3qJUvjI/ULwDWPIc8MXdke0zVkr2Agv+Abw0AniiK7Dzx8Tun4gaEnQNlOb5mfjrGKX58IOfrcOUD9Zg8wElCXjlzqN49yfFnbvl9K6m27hlVFfkZaRhy8Fy3Pfprzh/xnehW6NwVyRVBBI5dPUX/p2qIVebetDxbfEQZKyTBlSHLkCicugibbbsEQQdX7ORQ/fWBcA/+wOHNim3s5sGh7pdbk1gi4UV1WXAi6cALwzWnLkKobACAHIEQSeHLJc8pwil1gOChbKILOh2BNqK+OuAfavNX8epqwa+mgrs+AE4slVZo8cLtOynOXR83XktlbxE7tAd2qQIRwAYdL1yueELLacxESz4h9ITb99qoPwA8PkU63N1k8mcKxQRGm1ovB5AZ6oGzGWD2uGcPi1R52f4cMVunPXsN3j8i99w/VsrUOPz46zeLTCkcxPT17cuzML824bh7jE90DTXi11HKkNXvvKE6gyDAd9OhHLo6i9yUYRZPlW08NBkrM5fTjN9flq8BR2zwaEzE3Q15cCO7xSx9ctc5b4cg78vLhfQrKdy/fdftPs3L1ReW3lUEWeAUBQRiCLwkKuvRqkgLTuoPKdkL/DTK8pjI/8e+r2IVa6MATt/0B7bvSz0awFgzXvAd88AH16ticFWxytCnws6TtPAD+bGAUFXcUhxHTMKgDMfUkaT1ZYDWxeZ72/PCuCV04G3LgTm3613MCOFMWDb/5Trp9+nrOP3n4G1c6LfZiIo2Qes/7ciQncsSfZqkgadqRowbrcLMy47AR/fNETNqXt+8RYcLK1GjxZ5eOqP/dRxYma0aZSNG0Z0Vp28l/63FbU+k1YDTToD588Axj1v91uJD6kWIiasI7ctsdOhA7Swa6yVs243UCDMG413UQQXcpE6dDpBF1ivLOiObNWub5yvXHJHTab5ccrl/p+1+9b9W7v+0ytKCFVtfRIQhumZ2g/GQ5uAGYOAp7oDb/8B8FUD7QYDXU4P/V5UQVeuhEDF8K0s6DZ/Ffw+Ny9ULkv3AosfVa63HRRYX5a+l1/T7splZr4mRgGgy2mKu9vjXOX2+s+M18oY8NntwJ7lwJavgaUvAN88Yfzc0v3AoocVQWzGoY3K+03LBAZPBobdrtz/34di65FXXQYc+E1zZkOxcYHyHsK1rBFR+/xBE6RmVJUAlcXWt51CkKAjcHw7pVfdc3/qj4KsdDQLNCTOybB+8vjjiW3RNDcDe4or8cmqPSF2drnWi8npUMi1/iJPRpAT82OFF0bYIRQL2mrX4yXouCPG3Si5bUk4+LoatdfWW7pfX6UqTkLgosLsc2/RV7nkDl1tpVbQkNdSyWn79mkth06slOXX138KVB5R3LoD65T7Trs3fDWzGHLlUxy4SNy1TAvl/jJXEYpvXaCFJH21wFZBUPA8wjaDtPvE+bFF3bXrPI8OALoGeuT1DAi6DfO0UWiHtwAfTFQqdtf/R3GlvLmKAAOA7d8Zv68F/wD+95jyuZnBX9tmoHLsnnSD8n2W7AFWvmX+ulB89QDwSGvg+ZOAf50I/Pyh+XPLDyvv7b8PARu/sL4PnaD7xvx5tVXA84OBZ/ua5wYun6n8YKgLkxPuQOhMRQBQRoWd3781frrndCy+cyTaNs6O6PWZ6R5cO6wjAOCFxVsMK2dTDrUogv6b1Dtkkd5xuL3b5w6dLYJOyKOLl1vc9QzlctNCRbDwQfJyk2Qz+l4CtDpBqeTMbhooBmF698qox5rcsoTTQnLotvxXCYHmtwHOm67ct/QFJccL0Bw6QHO6NgRcwPZDlSKIIbeY954TEQXdjoDAPf5y5bMv2698Nn6f5r4d2qiE+wBg93KgukRJLxELYtqKgk4IuzYVcpSbdApccWlTLNoNAbIaK8J05/fKd/Pvm4FfPwbe/RPwecBBO/lGYNgdgfVsUELNIr5aYFOgZYuZ4AO0cCX/nNIzgSE3K9dXRSHoGANWvhnYVuCc8ukkYPcKYPPXwLpP9bmOP87QKs83fG59P6I427fW3IXcOF8R2dXHFCG+7lN9e5qti4HPbgPmTQFeHqn0EEwh6ExlwIwZM9CrVy8MHDgw2UtJOBlpHmR7o3MBLj+5PQqy0rH1UDnm/xJDHodT4K5FUc/kroOwH1kYmY2BihYuhGKtcgUkhy5Ogq7jcCU8XLwDWP0OcHSbcgJuN9ja60+7B7hukZI76HZrgkwUAWLIlZNtkqPbvLdyWbJHyYHj4dZe5ynf1ZBbtM/Wna7fDq905QKyz8XAZR8AZz5o7b2oIddSzaHrfLr2nnYvUwTVoQ3aa755ShEmW75WbncZpewXUGbGiiJOdOiaGjh0rU/Q3oMnDeh+tnJ9yXOKSOWii/mV8GhmoeLOZTfW/laJeX/8dlWgCfy+NUoIVIYxTey1H6rd3+di5djYv1YRS/y5Vji6TSsKuXML0OUMJZz/6mnA2xcC718JrHlXeW7lUWDpy9prN3xhXIxRXao4eZyaCm0SR3YTAAzYvkSrqBZZHdhXRoGSP/v+lcDDrYF3LlZCsV/zY8QFHPgVeH2Msq0UgQSdAZMmTcK6deuwbJmFBFhCJTcjDROHdAAAzFi0BSzwn/5YRS0emb8eH6+yMLDbSfQ6X/kjNPimZK+EsBvRdc1toQkIu8iwM+QqOHTxCrl6c7SmwV/8TbnsfYGS2xUNw6Yolz++oIReAU1giX36zHLoMgsUIQQo4TTutvU8TwmZnvkgcPs6YPQjwAUv6j9neZttIvxhzh26A78BR7crbm7bQdp2fv4QWPyIcv3km4D0HKVwYNMCrUK1yygl/6yop+KeiXBxl5GvF3r9L1dy5kY9oH/+oGsV8br5K+CDCcp9Q25Wwse8eCKrULmff4e8GIPz2zztOvMBu38SbjNFNB/eApT9ruxL/MyyG2uicuWbSs7eYx2A76creW7lh4ED640/S96Dr2U/wJsN/OFVZWYvoOVnfj1Nccl+eF4R0c16Kd9/xSF9zuLhLcC8O4EnuwHP9dX2uWeFUoGc1wroNS6wzjeUPn7PHqcIWEDJueTfz1XzgIHXBsR1YBzcS8OUXMT0bODG7xURX1cJzL5EcRRTABJ0hK1cNbQDcrwerN9Xgv+s3Yf/bTyIs//5LV7631bc8f4arN1dnOwlRoZZSIhIbUSHrvNp9k2J4MQr5BrPlj+8N1t1YHrM8ZdHv63uY5S8sdoKLUmf59Add4H2vFD/v1r0US4X3KuEyBp1VEK64msH3wT0uUj/OrG4ID1Hc9qtwgUdD+d2OlURtlzk/PaZIk4zC4GRfwNODDQcfu9SLUTX+TSlCGzSjwaCLuDQNe2qP+5yi4A/vQN0HKZ/fqvjgYtnKsesr0YRcafcDgy/E7hrO3DCFdpzVUEnuEqMKTl4gPbZ7BAcvCXPAY93BF4LuNRtTgzOneTHwrJXgOWvAVXFyvfyXD/gyS7A8ycDawKVsOWHlHCq2IOP5xBmFQLXLgSu/Rr46xZFtJfuA944D/jmceU5w6doOYS/fQ7sWQm8dxkwfQDw08vKMVVTBvznNkVQ7gqEW9udBHQaoVzftEApSqk8Crx9kTIj9+cPFTHb+kTFbT3nKeCO35S1ZOQr4h1Qvq/mvZTvosMwRWS+dgbw4TXGIdi6msS2lQkBCTrCVgqzvbj8ZOWX9S3vrsKE13/CnuL/b+++w6OsErePf2cmvZOeEAIJhBIgSAdpIkhRseGuAiqWlQXBvv5cK7rvurq6q6sry9rZVVewoQg2BOlFQErohE5IgCSk95nz/jEwEIEQNckk4f5cVy7IPM88c54cZnJzagkeVgsOA4/N3ozdYThWUMa079NcS6WI1KvTg9H5Zj3+EidboWq9y7WOWujA2R12Ulibmne3no3F4lz2AmDdDDiy9dTaaxeNO3VedZNRTga6ky17/e+v2XjWgNNa6Jp3+/khOOjELF2L1bkW3PVvO79vO8IZ6iI7QodRzsd9gpzhKr7vqTX8Tl9v7myShkJEe+g2vuZlan8FXDPd2XJ12VOnlmn56c/jZKA7svlUF+vRbc6udJs39L/P+djJLlljnK1ZcGrc2dnGGba+9NS2ZTYv6DPZGZbzDji7fgG+eQSO7YA3TnSnbv7kVEvg6WMIfZs5Q6OXP1z2J+dj6Wudf/a5CzpeB+1PtAiuect5ve1zAeP8Nzr6LedrH1wFK/8JaQtPvEYfaHla2Zt3h6jOzmD+rz7OlkCALjdWvbe4HjDuY+c1/SNOjRn09IUxM6HtSGcQ3Pyxc1zdjCudY+0ACo7Af0bB3PsbxFZtdfjpIBeqOwYk8PG6Q2QXlRMe4M3QDpFMHNSaUa8uIzU9j5EvLyHtaCEn503sOlrIHf0TCAs49cvvQHYxEYHe+HppyRCpA64WOouzBaa21WoL3enLltTh+yE8ydlikrv/xCSAX9lqmTDAGXQOrDzVRRkQ7QxFfuHOGaohLc79/JOBDpxh4qe/iM/l9C7Xn9vdCs6ty2753FnWyPanHvcNgd99d5bXC4Pbv3aGmd0LneGnOqGJMHl19eecTZcbnF/VCYp1tmQe3+tsMQtrfWryRuIgZ1fwN486uzIry+D4fufYRqsnXP6C8+99J595XavN2cW7chqM+AskXuJsyUpf6wywM29yjjn79wDn8jDgfN2Te9OeHuhOl3y1MzDtWeR8/ZOtjW2GOoPjyQkSKTc4g/PJ+ig84ryP+U+eulZ8b2ddXPq4s7VtxHPOrtz/XHVqvKN3EHQafWY54nvDPeudId632anHvQNg7Ezn2MGVrzpD6r6lzq8OVzl/jgUZJ0LzAecsbzdSoJNaFxnow/I/XkqlwxBw2tInD49oz+OfbWbnEedA1a7xIWQXlnMgp5gvN2dyc5+WGGOY9n0af/t2J4kR/nwy8WKa+f/KtbxEfupkV1+L3mdf3PbXCohy/nn6L4dfysv/1EzHulwT0WKBy//mbA3p+bvauWaXMc5Ad3IWaFgbZzi4ebaz5aS6lqyTa9EB9Lun5uH49C7XXxLowBlYfq6IdlWXIXGXlv2cge6rh049ZvVwtn6Ft3VOHCjOhsMbTnVXJgw41XV8Ll3HOb9OCmlxKpBf+RK8PcwZ5nxCnJMZsk+sORcU5wyaZ2OxOLs27RVVu3m9A50tvHuXOltmW/6ktbjX753jKg+sdI5TTBoKMRc5jw18qOp1Jq1w/iel8Ihz+MLJ1s2fCow6973HpMB1r8OQqbD8H7DmzVP/psPbwZgP3B7mQIFO6oiP55m/eMb2iqes0oExhuEdo2kR6sfrS3bzly+388XGw4ztFc/jn6W6th3bc6yI37+3jnfv6IW3h41lu7L469fbuSIlhomDWtf3LUlTEtcTxn5Y+5MhTupyo7MLrsNVtXO9kBbOQFeXXa7g3LS+uo3rf67kq50D2U+22pxcmiMm5fzPDYl3zr4tOf7zuicDTg90PWr+vKai72Tn7ODj+5zjIZOvgX73ngoc8X2doX3TrFMTC9qO/HWvGd/bGbzWvw+/meFcIuXkbh7nap07yWo7e8vzxXef6v78KZsHjP/C2d17vlZrm4ezpTKsFn5nBDd3tiReNBbmT3V2z1/+/KlJUG5mMaYBdPw2UPn5+QQHB5OXl0dQUCPZrqqROZxbwsXPLcRigWsvas6n69OxWmDSJa3574r9FJRVkhQZQLvoQOalZmAM2KwW5t8/kMSIGq6RJdLYzRzn/CU86I8w+BF3l+bn+fAW53pf4Bwz1e/en/d8Y35e96/D4VyjLTDq1Jp1ckrad84FkQGwAAbuS61+f9ufqyAT/tHZOYljxHNnTgyRn6WmWUSTIsStYkN86dmqGcbApyd2mHjphot4aHh7/nVTN7w9rOw6WsjcTc4wFxHojd1h+Pv8nW4uuUg9ir3I+Wdt/tKtLymnjfs6fTeEmvq5Y/msVhj3ocLcubQZ6twBAgDjnORR2/+uAqOdY9miOp1aSkTqnLpcxe1GdYllzT7nDKsHLmvL1Rc5B4EPSIpg2cOXsmJ3FqmH8uiVEEp8mB8jX17KvE0Z9EncT6XdweB2kbQK93fnLYjUrX73Q7srfv4SHA1Bm8uc49qKs+qui1t+nqFPOxfMPZLqnEFbF/rd+/NbY+VXUZdrNdTlWj/ySiq4Y8YaUuJCeOLKDljO8z/yB2ZtcLXmAbSJDOCb+wZis1o4XlROsK8nVmstrysmIr/c0e3OSRC1vcWa/HIFmc79aLvdcmpWtjRINc0iCnTVUKBrmA7nljDpPefK3buPFVFYVsmrY7viYbUy5X8/0iYygFfGdKVtVMMYqCoiIvJLKdDVAgW6hu+l+Tt5ecEuEsP9ySosI7/Uubinl4eVG3u2YFhyND0TmuHtofXsRESk8VGgqwUKdA1fbnE5/f/6PYVlziCXEhdMmL8X3+845jrHy8NKt/gQHr8imU7Ng6s8/2h+KRGB3uft5hUREXEHzXKVC0KInxc393Wur+TvZeOVG7vy9q09eefWntzQowXhAd6UVzpYtSeHez5Yj+PE9hQOh+GZeVvp9ZcFjHljFceLyt15GyIiIr+KWuiqoRa6xqGgtIIXvtnBZclRDEiKqHLMGEPa0UKum76CgtJK3rylB5e0i+DhT1L55MdDrvPiQ/2YflM3OsYG//TyIiIibqMu11qgQNd0PPvVNl5bvIdeCaHENfPl0x/TsVkt3D80iVlrD3IwpwSb1cId/RO4qEUINquFQW0jzrrjhYiISH1RoKsFCnRNR0ZeCQP++j2VJ7pcbVYL08Z2Y0SnaHKKynn8s1S+TM2s8pwuLUL43+964++t5RpFRMQ9FOhqgQJd03LvzPV8vuEwAC/d0IVru8ZVOb5g2xHeWraXCruDHZkF5JdWcnHrMAa3i2RPViHhAd60jgjgsuQohTwREakXCnS1QIGuadmbVcQfPtrIDT1a8NueLao9d+PBXMa+sYqicvsZx6KDfJg6KpkRnaLPOzvWGMPH6w7x9eZMbrm4FYPaRlR7voiIyOkU6GqBAt2FbdWebJ6Zt43YEB/aRgWSVVjO0l3HOHS8BICOsUHcenErrr6oOV4ezgnj2YVlpOeWkJFXSkZuCV9vyWTVnhzXNcf0asETVybj56UWPhEROT8FulqgQCc/VVph51/fp/Hakj2UVToASAz357b+CXy9OYPladlnPMfH08rApAi+3XoEgN4JobxzW0+FOhEROS8FulqgQCfncryonJlrDvLWsj1kFZ5aw85igchAb2KCfYkJ9qFFqB839W5JfJgfK9Ky+P276ygoq6RPYijv3NoLXy/NohURkXNToKsFCnRyPgWlFbz6fRpfbDjMZclR3Dkwkbhmfuc8/8cDx7nlrR8oLKvkzgEJPHZFcj2WVkREGhsFulqgQCd1YeH2I9w+Yy1eNivzHxhIyzD/n/X80go7B3KKaRsVWEclFBGRhqKmWUSDeETq2aXtoxiQFM7SXVk8/cVWkiID+PHAcbq3DOXKlJgz9ps9XUm5nRvfWMXGg7m8eUsPhiZH1WPJRUSkoVILXTXUQid1ZXtmPpe/vBTHWd59N/RowZOjks9Y687hMNz9wXrmpWYA0Ll5MHOm9Dvv0ikiItJ41TSLWOuxTCJyQvvoIG69OAGA7i2b8fRVHRnRMRqLBWatPciV/1zG/K1HMMZgdxhW7clm4nvrmJeagafNgreHldT0PJalZbn5TkREpCFQC1011EIndckYw7HCMiIDfVyPrdydzQMfbiAjrxSA5iG+ZBeVUVrhcJ3z/PUpbMvI553l++jUPIgwf2/SjhZy1+DWjOkZj9WqFjsRkaZCkyJqgQKduENecQX/XrKb/6zYR/GJnSr8vWxcdVEs43q3pFPzYA7nljDohe+psFd9+7aLCqRT82BS4oIZ2zseT5sa4UVEGjMFul9h2rRpTJs2Dbvdzs6dOxXoxC2yC8tITc8jPtSPlmH+2H7S8vbi/J38b/V+rkyJJTbEh38uSKOgrNJ1fGzveJ65ppNrjN3RglLSjhTSItSP5iG+askTEWkEFOhqgVropDHJKixj6a5j7DpSyPTFuzEGHhrejr6tw/hmSyYzlu9z7W4R7OvJ6G5x3NQnnsSIADeXXEREzkWBrhYo0Elj9caSPTzz5bYzHo8J9iG7sJxyuzPY2awWHr28A6NSYnj2q+0cKyjjn2O60szfq76LLCIiZ6FAVwsU6KSxMsbw0vydzFp7EE+blZhgHyZd0prB7SKxOwxL07J4Z/k+luw8BoCXzeoKedd3j+Nvv+nizuKLiMgJCnS1QIFOmjJjDO8s38czX27D7jC0iwpk59ECjIH37uhN/6RwdxdRROSCp3XoRKRaFouF2/snMPuui3n5xouYd09/bu7TEoBHZ6dScmKGrYiINHwKdCIXuJS4EK6+qDkeNisPDW9HTLAPB3KK+ceCnWc9v9LuoOi02bQnGWNQg7+IiHso0ImIS6CPJ3++phMAby7dy+b0PLIKy8gqLAPgQHYxg/++iAHPf8/erCLX80or7Ix7czVXvbqco/mlbim7iMiFTGPoqqExdHKhmvK/H5m7KQM/LxvF5XasFri2axyr9mSTnlsCwEUtQvh4Yl88bFaemrOFGSv2Ac49Zmf9vg9+Xh7VvIKIiNSEJkXUAgU6uVAdKyjjspcWk1tcccaxxHB/jhWWUVBayW39WtE2KpBHPk0FINDHg4LSSrrFh3B55xguS46iZZh/fRdfRKTJUKCrBQp0ciHbc6yQtKOF9GgVyv7sIl5esIuScjv/HNOVFbuzuW/Whirn33pxK0Z1iWXMG6soP7GAsa+njXn39NfixSIiv5ACXS1QoBM5O2MMbyzdw7xNGeSXVpIQ7s+/xnXDx9NG2tECvtlyhC82HmZ7ZgE9WzVj5oS+zN96BE+bhUvbR7q2IxMRkeop0NUCBTqRX+7Q8WKGv7SEonI78aF+HMgpBmBUl1j+b3g7bFYLkYHeeNiqzs3afayQAG8PooJ83FFsEZEGRYGuFijQifw6767cxxOfbwGc3a/ldgd2x6mPnOYhvrw5vgcdYpzvr6W7jjH+7R/w9/Jg7j39Nf5ORC54WlhYRNxuXO+W3NE/gRt6tOC7Bwfx8cS+tIsKxGIBqwXSc0v47b9XMnfTYXYeKWDK/9bjMFBQVsnk//1IWaUWNxYRqQm10FVDLXQite/kR05+SSUT3l3L6r05VY53ah5E+vESjhdX0D46ED8vGx1igrj70iSig8/shs0tLiersByb1ULLUD+sVo3PE5GmQ12utUCBTqRulVXa+ds3O5i3KYPDeaVEBnozZ0p/tmXkc9uMNVXO9fG0MvmSNtw1uA22E6Ftb1YRl7+8lJIKZ0te95bNeP93vfHxtNX7vYiI1AUFulqgQCdSP4wxHDpeQpCPJ8F+ngCsPrGIsc1q4d2V+1m7/zgAfRPDeHnMRUQG+vDArA18uj4dbw8rdoeh0mEY0yueZ6/r7M7bERGpNQp0tUCBTqRhMMbw2YZ0Hpu9meJyO81DfHludGfGv/0DDgNzpvQjt7iC8e/8gDHw+BUduKVvK7w8NExYRBo3TYoQkSbDYrFwbdc45kzpT0K4P+m5Jdz8ljPMDWkfSUpcCAPbRnD3pUkA/HneNi5+bgGf/njIzSUXEakfCnQi0mi0iQzggzv70DLMz/XYvUOTTv19SBIPDW9HZKA3WYXl/PGTVA4dL3ZHUUVE6pUCnYg0KtHBPvzvzj70bNWMO/onkBIX4jpms1qYPLgNy/94KX0SQym3O3jx253uK6yISD3RGLpqaAydSOO16VAuV726HIsFJgxIZOH2o3SND+HxK5PZnJ7Hi9/uZGhyFBMHtXZ3UUVEzqmmWcSjHsskIlJvUuJCGNUlli82Hua1JXsA2HW0kIXbj5JVWA7A2v3HiQn24eqLmruzqCIiv5q6XEWkyfq/4e2ID/UjJS6Yx6/oQItQX1eY69Tc+T/dhz/ZxLr9OdVdRkSkwVOXazXU5SrStBSUVvDuqv10bh7Mxa3DuW3GGpbsPAbARS1CmHRJa4Z3jObL1AyemrOF3olhPDUqmbAAbwDSjhYydc5m+iaG8ftBrfG06f/EIlK3tA5dLVCgE2na8oorePSzVL7ZnEmlw/lR2KVFCBsP5rrOCfP34q+jU+ifFM7Vry5nx5ECAJJjggj08WDL4XxahPrROyGUiYNan3V7MhGRX0qBrhYo0IlcGI4VlPHO8r28vmSPK9iN6dWC9Qdy2Z7pDHCdmgexOT2fUH8v7A5DXknFGddpHx3InCn9taCxiNQaBbpaoEAncmHZnpnPa4v3MLBtONd2jaOs0s6zX25nxop9rnP+c3svOkQH8uHag4T6e5MSF8z+7GKe+HwzOUXlPHBZW+4ZkoQxhsN5pew5Vkjn5sGE+Hm578ZEpNFSoKsFCnQiAvDZ+nRe+GYHY3vHM3lwm7Oe8/mGdO6duQFPm4VL2kWy8WAuRwvKAPCyWRnWMYr7hralTWRAfRZdRBo5BbpaoEAnIjVljOHO/67lu21HXY/ZrBYiA73JyCsFwM/LxrPXddYyKSJSY1qHTkSkHlksFp6/vgvTF6UREehN1/hmdIoNxsfTypbD+fzly22s2J3NvTM3kFNUzm39EgBwOAxWq8XNpReRxk4tdNVQC52I1Ba7w/D8N9t5bfEefDytzL9/EN9uPcJzX23jmWs789seLdh5pIB/LkzjohYhjEqJITJIM2ZFLnTqcq0FCnQiUpuMMYx9YzUr92STEO7P3qwiAMIDvFj80GBufH0Vqel5AHhYLbw6thsjOkW7s8gi4mY1zSKaWy8iUk8sFgvPXNsJL5vVFea8bFayCsu57Z01pKbnEeDtQUpcMJUOw/+bu5XySoebSy0ijYECnYhIPUqMCODBYW0B+E33OP58TScAftjn3H7srsGt+fD3fYkM9CY9t4RZaw+e81oZeSW8v3o/hWWVdV9wEWnQFOjOYtq0aSQnJ9OzZ093F0VEmqDfD2rNmseG8sJvunBdt+a0CvMDoHmIL7f3S8DH0+ZaHuXVhbvIKizD4ag6OuZAdjHXTlvBY7M38/t311JhP9WSV1Jup7hcIU/kQqIxdNXQGDoRqQ9Ldh7jyc83M/WqjgxuFwlAWaWdwS8s4vCJJU98PK1c2zWOm/rEk5FbytQ5W0jPLXFdY1SXWIwxLN55jILSSrw8rDxxZTI392nplnsSkdqhSRG1QIFORNzpq9QMHp2dyvHiM7cZA0gM9+fOgYk8OjuVc32SP3NtJ8b1VqgTaay0Dp2ISCM3snMMIzvHUFZpZ8OBXP61aDfL0rJoFeZHr4Qw7huaRFSQD5V2B68t2cPgdpGM7h5HYoQ/ry5M4/Ule3hs9mYqKh3cemLdu4y8En7cn0tBaQXXd4/Dw6aRNyJNgVroqqEWOhFpaGq6ELExhmfmbePNZXsBuK5bc3ZkFrDlcL7rnIdHtGfSJa3rrKwi8utp2RIRkSaoprtKWCwWHruiAw9c5pxR++mP6Ww5nI/NanFNwpi+KI2807pzK+wOsgrLar/QIlLnFOhERJooi8XCPUOSeH50Cn0Tw3jyymTWPjaUBQ9eQtuoAPJLK3ltyW7A2fL3u/+spc9fFjB/6xE3l1xEfi51uVZDXa4i0lR9uyWTCe+uw9fTxhd392PJziz+NHcrAIE+Hsy7ewB2Y1i3/zgl5ZWEB3gzvGM0VquFCruD/JIKwgK83XwXIk2fZrnWAgU6EWmqjDFc/++VrNt/HF9PGw5jKKt0EB7gTVZhGUE+HuSXVl3LbmSnaO4cmMgfPtrInmNF9G8Tzu39W3Fp+yg33YVI06cxdCIick4Wi4XpN3WjX5swSirslFU6GNg2gjlT+hHq70V+aSVWC/RKCGVYchReNitfbc7kun+tYM8x57Zly9KyuH3GWhbvPHbO1/npgsgiUjfUQlcNtdCJSFPncBjeWbGPDQdzeeKKDkQG+bAjs4CVu7MY3imamGBfAFbtyWbCf9eSX1rJ0A5R3Dc0iemLdjMvNYPkmCDm3t2/yoSNLYfzeOTTVI4VlPGf23vRNirwvGWpsDuwOww+nrY6u1+RxkZdrrVAgU5E5JTDuSXsPlZI/zbhWCwWcorKGfj89xSWVfKnqzuyPbOAH/cfx8/LxqZDeVSeaJ2LDfbh07v6ER3sc85rV9gdXPnKMrKLypn1+z60jgior9sSadDU5SoiIrUqNsSXAUkRWCzOlrhQfy/uHJAIwJOfb+F/qw84Q92BXCodhhEdo0mM8OdwXim3vvMDRWXOMXlFZZWs2pPN9zuOcuh4MQCz16ez40gBWYVl3PbOGrJPWz4lp6i8yvcicibtFCEiIr/YHQMSeHfVPrIKy2kfHcg9Q5KwWiA8wJserUI5mFPMddNXsD2zgKlztjBlcBtueH0lR/KdAc3DauGN8T2Yvsi5fIqnzcKBnGImvLuOWRP6UFhWybCXllBhd/DlvQOIDvLhr19vx+4wPDisLX5e+jUmAupyrZa6XEVEzi/taCE7jxRwWXIUnmfZSmzVnmzGvrEKh4EQP09yiysI8/fC39uDAznF2KwW7A5DiJ8n/729Fze9uZr80koeu7wDGXmlvL3cudvFgKRwUuKCmfa9M/y1jw7kjVt60CLUr17vV6Q+aQxdLVCgExGpHf/4bif/+G4XAK3C/Pho4sUE+Xpwy1s/sHpvDgD3D23LvUOT+HDtQf7v4034etqodDiosBs8rBbXmDxwrpVXUFpJRKA3X907gPAAbxwOg8WCq0tYpCnQGDoREWkw7r40iWu7NqdLixDe+11vIgK98faw8drN3WkfHUjzEF9uvbgVAL/pHkevhFBKKuxU2A2D2kbwfyPaua5168Wt+Oa+gbSO8OdYQRl//CSVLYfzGPz3RYz4x1I2p+f96vLaHYZp36exaMfRX30tkfqgFrpqqIVORKTu2U+0vNlOW/Yk7Wghl7+8FLsxfHnPANpEBvDwJ5twOAzPjU7By8PKtox8rn51OeV2R5UWPC+blYdHtuf2fq1crXXGGLKLygny8cTL4/xtGZ+tT+e+WRvw8bTy3QODiGumbl1xD3W51gIFOhER99l0KJcKu4PuLUPPec6bS/fw53nbAOjXJgx/Lw++PbEX7eB2EQxIimDupsNszcintMJBqL8XEwcl0j46iG0Z+UQEejM0OYogH88q171m2nI2HMwFnDtkTL+pe93cpMh5KNDVAgU6EZGGzeEw/OO7ndisVu4a3BoPq4X3Vh/g/83dSnmlo0bX8LJZubVfKx4Z2R6LxcLGg7lcPW05njYLDuNsQXz3jl4MSIpg55ECHv00lcHtI5k8uE0d352IAl2tUKATEWmctmfm88inqQBc3SWWgW0jiA3x5YuNh3lz6V7K7Q46xASyI7OA3Se2MntoeDsmD27DA7M28On6dK7t2pwQP0/eWb6PIB8P7r40ideW7CarsByAmRP60Ccx7FeVMzOvlFlrDnL1RbG0Cvf/dTctTZICXS1QoBMRadqMMfx35X6mztkCwKC2ESxPy6LSYfhscj9aR/hz81s/uLpfAbw9rJRVOkiM8OeLKf05dLyE+FA/fL1sVa67ZFcWMcE+59z2bPHOY9w/awM5ReV0bh7MnCn9NENXzqBAVwsU6ERELgxPzdnCjBX7XN9f3DqM/93ZB4BKu4N/LdrNKwt20TE2iFfHduO66Ss4VlDmmozRPjqQmRP6EOLnBcAXGw9z9wfrAegSF8xVFzVneMco4pr5kV1YxvNf72DW2oNVyvDJpIvp3rJZ/dywNBoKdLVAgU5E5MJgdxjeWrYHh4GerZqREhdyxiLJBaUV+Hl5YLNa+Co1g0nv/1jleJe4YN77XW8CfTy54bWVrvX1TndyJu/Jmb0392lJfmkFn284zFVdYnllTNcaldfhMOzLLiIh3F+tek2cAl0tUKATEZFzST2Uh7enFWPgxtdXcry4goFtI5g6Kpkhf1+M1QJzpvRnzb4cvt6cyZp9OZxcG7ljbBB/uroj3VuGsjk9jyv/uQwPq4XvHhgEQHSwDwBvLdvL7PXpJIT7M7JTNK0jAsgrqeCFb3aQmp7Hb7rH8fz1KQp1TZgCXS1QoBMRkZrYnJ7H9f9eQWmFg4Rwf/ZmFXFp+0jevrWn65yiskqKyiqpdBhign2qhLDR01ewbv9x1/dWCwR4e5BfWnne1376qo6Mv7gVhWWVfLjmIMvTsrhvaFs6xwXX7k2KWyjQ1QIFOhERqal3V+3nic82u75/7ebuDO8YXaPnLtx+hNtnrAXAy8PqWnIlOsiHu4e04UheKYt3HuNoQRklFXYu7xxDeIA3ryzYhYfVQtuoQPZnF1FUbgcgMdyfr+4bwLp9x3npu52UVNjx9/Lgpj4tuTIl5owWvezCMn7Ym8Pg9pH4eNqQhkOBrhYo0ImISE0ZY/jdf9ayYPtRIgK9WfHHS88Yh1edrMIyvDysBHp7cLSgjIM5xSTHBuHn5XHO17tn5ga+2HjY9VhiuD/5pRVkFZZzbdfmfLMlk+ITIe+kHi2bER3sg91h6J8UTpCPJ0/N2UJ2UTntowN5+cauZBeWcSCnmGu6NsfH00ZJuZ2tGXl0bdEMq/XM7t1vt2Qye306nZoHc0m7CDrGOlsH//r1dj5ae4iUuGAubR/JmF7xVXYEORe7w1BaYcff++z3fiFRoKsFCnQiIvJz5BSV8+yX2xjeMZqhyVF1/nrllQ4Wbj+Kj6eViEBvOkQHMTc1g3tOzLAF6N8mnDsGJLD+QC6vLd5N2TkWXLZY4KeJYGiHKF64PoWxb65mW0Y+IzpG8+INXaqEzF1HChj16jJKK05d9++/6UJChD/X/WtFletNuqQ1D49oX+09bTyYy32zNpCZV8pfr0/hqi6xNf1xNEkKdLVAgU5ERBobYwy3vP0DS3dl0T46kI8m9iXwxNZmB7KL+WZLJh42C8XlduZtymDHkQJu79eKW/q24g8fbWT13hzCA7zJL62gvNJBiJ8nucUVrus7J3R0onvLZpRW2Ln2XyvYlpHPRS1CCPTxYOmuLHw8rTQP8WX3sSJGdoomKTKAVxamAfDq2K50iQth6a4sZq45QG5xBXf0T+DS9pG8v/oAby7d49qXF2BUl1iKyiqxWuDKlFi6xTdjX3YR/t42usU3O6P7uLzSwf+bu5XDuSWM6hLLsI5R52zlrI7dYfh2Syb+3h4MSAp328QTBbpaoEAnIiKNUV5JBXM3HWZkpxhC/b2qPbe80oGXh7Nr2BhDTlE5zfy8+HpLJpP/9yPGQJCPB49d0YHnv95BdpFzp4x2UYHklpRzJL+MMH8vvrpvAOH+3tw6Yw1Ldh4DINDHg4UPXkJEoDfPzNvKG0v31qj8l3eOJjbYlzeXVX9+t/gQbuuXQMswPyIDfQjw8WDy+z+y+MTrA0QEejN9XDd6tDr3nsCnM8bw7dYj/P3bHew8UghAr1ah3Ds0iT6JYTXqMq5NCnS1QIFOREQuZLPWHODDtYd49PIOdG/ZjPTcEl7+biez16dTYXfGBx9PK9Nv6s7gdpGAs9v5ileWkpFXytRRydzWLwFwLtB824w1LN2VhZfNSmKEP6O7xeHjaeWl73aRU1ROn8RQbuuXwLDkKCwWC/O3HmHNvhziQ/04VlDGp+sPkZlXSnyoH+m5JVW6eU/n62ljTK94vtmSSXpuCZ42C3++phM39IzHGMML3+xgf04xvVqFMrhdJPFhfgCs2J3F81/vcO0MEuTjQVmlw9VNHRHoTYtmvs7dPeJCeOKKDkQG+dRlFSjQ1QYFOhERkTNl5JWw8WAuEYE+tI7wd+2QcdLBnGI2Hsrl8k4xVSZR2B2G3GJnC+Dpj5dW2CksqyQ8wPu8r+1wGKxWC0fzS3l9yR7W7MvhSH4ZxwrLsDsMzfw8eeOWHvRoFUpxeSUPfbSJeakZgHM3jmMFpUx879Si0FYLXN45hrySCpbuygKcgfD2/q2YMLA1xeWVvLowjS82Hj5jGZlgX0/+dHVHruoSW2ddsgp0tUCBTkREpHGwOwzZRWUE+3ri7VF1X937Z23gsw2HaR8dSEmFnf3ZxQxuF0FJhZ1Ve07t6OFpszC2VzyTL21DZGDVlrfySger9mRTVFaJj6eNv8/fweb0fLw8rHz/h0toHuJbJ/dV0yyi+cAiIiLS6NmsljNCGIDFYuGJK5NZtPMY2zMLAGfX6atju+Hv7cHWw/n8d+U+vDys3DkgkRahfme9vpeHlYFtI1zf908KZ/qi3fh52eoszP0caqGrhlroREREmoZZaw7w8CepADw/OoXf9mzh5hLVjFroRERERE74TfcWpKbnUVFpGN09zt3FqXUKdCIiItLkWa0W/nxNZ3cXo87UfE8SEREREWmQFOhEREREGjkFOhEREZFGToFOREREpJFToBMRERFp5BToRERERBo5BToRERGRRk6BTkRERKSRU6ATERERaeQU6EREREQaOQW6s5g2bRrJycn07NnT3UUREREROS+LMca4uxANVX5+PsHBweTl5REUFOTu4oiIiMgFpqZZRC10IiIiIo2cAp2IiIhII6dAJyIiItLIKdCJiIiINHIKdCIiIiKNnAKdiIiISCOnQCciIiLSyCnQiYiIiDRyHu4uQEN2cs3l/Px8N5dERERELkQnM8j59oFQoKtGQUEBAC1atHBzSURERORCVlBQQHBw8DmPa+uvajgcDg4fPkxgYCAWi6VOXiM/P58WLVpw8OBBbS/WAKg+Gg7VRcOhumhYVB8NR33UhTGGgoICYmNjsVrPPVJOLXTVsFqtxMXF1ctrBQUF6Y3ZgKg+Gg7VRcOhumhYVB8NR13XRXUtcydpUoSIiIhII6dAJyIiItLIKdC5mbe3N1OnTsXb29vdRRFUHw2J6qLhUF00LKqPhqMh1YUmRYiIiIg0cmqhExEREWnkFOhEREREGjkFOhEREZFGToHOzaZNm0arVq3w8fGhd+/e/PDDD+4uUpP31FNPYbFYqny1b9/edby0tJTJkycTFhZGQEAAo0eP5siRI24scdOxZMkSRo0aRWxsLBaLhc8++6zKcWMMTz75JDExMfj6+jJ06FB27dpV5ZycnBzGjRtHUFAQISEh3HHHHRQWFtbjXTQd56uPW2+99Yz3yogRI6qco/r49Z599ll69uxJYGAgkZGRXHPNNezYsaPKOTX5XDpw4ABXXHEFfn5+REZG8tBDD1FZWVmft9Ik1KQ+LrnkkjPeGxMnTqxyTn3XhwKdG82aNYsHHniAqVOn8uOPP9KlSxeGDx/O0aNH3V20Jq9jx45kZGS4vpYtW+Y6dv/99/PFF1/w0UcfsXjxYg4fPsx1113nxtI2HUVFRXTp0oVp06ad9fjzzz/PK6+8wr///W9Wr16Nv78/w4cPp7S01HXOuHHj2LJlC/Pnz2fu3LksWbKECRMm1NctNCnnqw+AESNGVHmvfPDBB1WOqz5+vcWLFzN58mRWrVrF/PnzqaioYNiwYRQVFbnOOd/nkt1u54orrqC8vJwVK1bwn//8hxkzZvDkk0+645YatZrUB8Cdd95Z5b3x/PPPu465pT6MuE2vXr3M5MmTXd/b7XYTGxtrnn32WTeWqumbOnWq6dKly1mP5ebmGk9PT/PRRx+5Htu2bZsBzMqVK+uphBcGwMyePdv1vcPhMNHR0eaFF15wPZabm2u8vb3NBx98YIwxZuvWrQYwa9ascZ3z1VdfGYvFYtLT0+ut7E3RT+vDGGPGjx9vrr766nM+R/VRN44ePWoAs3jxYmNMzT6XvvzyS2O1Wk1mZqbrnOnTp5ugoCBTVlZWvzfQxPy0PowxZtCgQebee+8953PcUR9qoXOT8vJy1q1bx9ChQ12PWa1Whg4dysqVK91YsgvDrl27iI2NJTExkXHjxnHgwAEA1q1bR0VFRZV6ad++PfHx8aqXOrZ3714yMzOr/OyDg4Pp3bu362e/cuVKQkJC6NGjh+ucoUOHYrVaWb16db2X+UKwaNEiIiMjadeuHZMmTSI7O9t1TPVRN/Ly8gAIDQ0Fava5tHLlSjp37kxUVJTrnOHDh5Ofn8+WLVvqsfRNz0/r46T333+f8PBwOnXqxCOPPEJxcbHrmDvqQ3u5uklWVhZ2u71KZQNERUWxfft2N5XqwtC7d29mzJhBu3btyMjI4Omnn2bAgAFs3ryZzMxMvLy8CAkJqfKcqKgoMjMz3VPgC8TJn+/Z3hMnj2VmZhIZGVnluIeHB6GhoaqfOjBixAiuu+46EhIS2L17N48++igjR45k5cqV2Gw21UcdcDgc3HffffTr149OnToB1OhzKTMz86zvnZPH5Jc5W30AjB07lpYtWxIbG8umTZt4+OGH2bFjB59++ingnvpQoJMLzsiRI11/T0lJoXfv3rRs2ZIPP/wQX19fN5ZMpGG58cYbXX/v3LkzKSkptG7dmkWLFjFkyBA3lqzpmjx5Mps3b64yrlfc51z1cfo40c6dOxMTE8OQIUPYvXs3rVu3ru9iApoU4Tbh4eHYbLYzZikdOXKE6OhoN5XqwhQSEkLbtm1JS0sjOjqa8vJycnNzq5yjeql7J3++1b0noqOjz5g0VFlZSU5OjuqnHiQmJhIeHk5aWhqg+qhtU6ZMYe7cuXz//ffExcW5Hq/J51J0dPRZ3zsnj8nPd676OJvevXsDVHlv1Hd9KNC5iZeXF927d2fBggWuxxwOBwsWLKBv375uLNmFp7CwkN27dxMTE0P37t3x9PSsUi87duzgwIEDqpc6lpCQQHR0dJWffX5+PqtXr3b97Pv27Utubi7r1q1znbNw4UIcDofrA1XqzqFDh8jOziYmJgZQfdQWYwxTpkxh9uzZLFy4kISEhCrHa/K51LdvX1JTU6sE7Pnz5xMUFERycnL93EgTcb76OJsNGzYAVHlv1Ht91MlUC6mRmTNnGm9vbzNjxgyzdetWM2HCBBMSElJlVozUvgcffNAsWrTI7N271yxfvtwMHTrUhIeHm6NHjxpjjJk4caKJj483CxcuNGvXrjV9+/Y1ffv2dXOpm4aCggKzfv16s379egOYF1980axfv97s37/fGGPMc889Z0JCQsznn39uNm3aZK6++mqTkJBgSkpKXNcYMWKE6dq1q1m9erVZtmyZSUpKMmPGjHHXLTVq1dVHQUGB+cMf/mBWrlxp9u7da7777jvTrVs3k5SUZEpLS13XUH38epMmTTLBwcFm0aJFJiMjw/VVXFzsOud8n0uVlZWmU6dOZtiwYWbDhg3m66+/NhEREeaRRx5xxy01auerj7S0NPOnP/3JrF271uzdu9d8/vnnJjEx0QwcONB1DXfUhwKdm/3zn/808fHxxsvLy/Tq1cusWrXK3UVq8m644QYTExNjvLy8TPPmzc0NN9xg0tLSXMdLSkrMXXfdZZo1a2b8/PzMtddeazIyMtxY4qbj+++/N8AZX+PHjzfGOJcueeKJJ0xUVJTx9vY2Q4YMMTt27KhyjezsbDNmzBgTEBBggoKCzG233WYKCgrccDeNX3X1UVxcbIYNG2YiIiKMp6enadmypbnzzjvP+A+n6uPXO1sdAOadd95xnVOTz6V9+/aZkSNHGl9fXxMeHm4efPBBU1FRUc930/idrz4OHDhgBg4caEJDQ423t7dp06aNeeihh0xeXl6V69R3fVhOFF5EREREGimNoRMRERFp5BToRERERBo5BToRERGRRk6BTkRERKSRU6ATERERaeQU6EREREQaOQU6ERERkUZOgU5ERESkkVOgExFpACwWC5999pm7iyEijZQCnYhc8G699VYsFssZXyNGjHB30UREasTD3QUQEWkIRowYwTvvvFPlMW9vbzeVRkTk51ELnYgIzvAWHR1d5atZs2aAszt0+vTpjBw5El9fXxITE/n444+rPD81NZVLL70UX19fwsLCmDBhAoWFhVXOefvtt+nYsSPe3t7ExMQwZcqUKsezsrK49tpr8fPzIykpiTlz5riOHT9+nHHjxhEREYGvry9JSUlnBFARuXAp0ImI1MATTzzB6NGj2bhxI+PGjePGG29k27ZtABQVFTF8+HCaNWvGmjVr+Oijj/juu++qBLbp06czefJkJkyYQGpqKnPmzKFNmzZVXuPpp5/mt7/9LZs2beLyyy9n3Lhx5OTkuF5/69atfPXVV2zbto3p06cTHh5efz8AEWnYjIjIBW78+PHGZrMZf3//Kl/PPPOMMcYYwEycOLHKc3r37m0mTZpkjDHm9ddfN82aNTOFhYWu4/PmzTNWq9VkZmYaY4yJjY01jz322DnLAJjHH3/c9X1hYaEBzFdffWWMMWbUqFHmtttuq50bFpEmR2PoRESAwYMHM3369CqPhYaGuv7et2/fKsf69u3Lhg0bANi2bRtdunTB39/fdbxfv344HA527NiBxWLh8OHDDBkypNoypKSkuP7u7+9PUFAQR48eBWDSpEmMHj2aH3/8kWHDhnHNNddw8cUX/6J7FZGmR4FORARngPppF2ht8fX1rdF5np6eVb63WCw4HA4ARo4cyf79+/nyyy+ZP38+Q4YMYfLkyfztb3+r9fKKSOOjMXQiIjWwatWqM77v0KEDAB06dGDjxo0UFRW5ji9fvhyr1Uq7du0IDAykVatWLFiw4FeVISIigvHjx/Pee+/xj3/8g9dff/1XXU9Emg610ImIAGVlZWRmZlZ5zMPDwzXx4KOPPqJHjx7079+f999/nx9++IG33noLgHHjxjF16lTGjx/PU089xbFjx7j77ru5+eabiYqKAuCpp55i4sSJREZGMnLkSAoKCli+fDl33313jcr35JNP0r17dzp27EhZWRlz5851BUoREQU6ERHg66+/JiYmpspj7dq1Y/v27YBzBurMmTO56667iImJ4YMPPiA5ORkAPz8/vvnmG+6991569uyJn58fo0eP5sUXX3Rda/z48ZSWlvLSSy/xhz/8gfDwcK6//voal8/Ly4tHHnmEffv24evry4ABA5g5c2Yt3LmINAUWY4xxdyFERBoyi8XC7Nmzueaaa9xdFBGRs9IYOhEREZFGToFOREREpJHTGDoRkfPQyBQRaejUQiciIiLSyCnQiYiIiDRyCnQiIiIijZwCnYiIiEgjp0AnIiIi0sgp0ImIiIg0cgp0IiIiIo2cAp2IiIhII6dAJyIiItLI/X+h5TvtePZcwAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -14167,7 +4680,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 67, "metadata": {}, "outputs": [ { @@ -14179,12 +4692,15 @@ } ], "source": [ - "model_builder.model.save('/home/da886/Final Electron counting project/Experimental weights/JoshMSE13fixed.h5')" + "# model_builder.model.save('/home/da886/Final Electron counting project/Experimental weights/Derrick5fixedGlobalPoolHuber.h5')\n", + "loaded_model = tf.keras.models.load_model(\n", + "\"/home/da886/Final Electron counting project/Experimental weights/Josh5fixedCustomloss.keras\",\n", + ")" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -14244,105 +4760,135 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n" + "Processing batch 1, batch shape: (800, 64, 64)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "W0000 00:00:1727101331.691257 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.697953 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.698127 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.698450 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.699025 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.699227 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.699643 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.700158 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.700489 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.700896 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.701345 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.701831 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.702340 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.702806 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.703388 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.703758 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.704273 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.704846 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.705205 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.705798 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.706204 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.706725 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.707230 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.707780 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.708337 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.708767 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.709229 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.709811 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.710291 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.710839 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.711345 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.711811 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.712162 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.712816 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.713028 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.713388 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.713798 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.714247 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.714708 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.715127 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.715728 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.716310 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.717041 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.717562 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.718468 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.719097 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.719926 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.727802 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.728468 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.729278 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.729913 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.736838 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.737402 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.737969 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.738633 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.739317 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.740088 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.740861 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.741658 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.742603 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.743364 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.744023 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.745162 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.745890 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.746789 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.747542 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.748775 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.749564 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.750828 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.751955 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.752965 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.753961 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.755438 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.756492 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.758252 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.759500 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.761264 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.762260 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.762734 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.764186 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.764686 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.766328 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.766971 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.768799 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.769932 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.770416 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.773477 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.773985 854852 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.777018 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.777849 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.779390 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101331.782622 854944 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + "2024-09-24 19:53:10.908885: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "W0000 00:00:1727207590.973229 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207590.994615 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207590.994964 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207590.997136 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207590.997408 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207590.997673 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207590.997930 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.007119 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.008471 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.009995 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.011385 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.025560 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.025846 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.026085 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.026315 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.026632 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.026917 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.027248 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.027613 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.027908 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.028313 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.028707 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.029186 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.034789 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.035311 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.035805 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.036278 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.036745 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.037257 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.038646 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.039177 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.039875 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.040562 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.041468 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.042268 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.043102 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.043934 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.044722 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.045514 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.046435 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.047450 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.048364 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.049165 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.050820 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.051159 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.052145 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.052545 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", + "W0000 00:00:1727207591.053922 1563009 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 1ms/step \n", + "Processing batch 2, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 750us/step\n", + "Processing batch 3, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 964us/step\n", + "Processing batch 4, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 908us/step\n", + "Processing batch 5, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 716us/step\n", + "Processing batch 6, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 720us/step\n", + "Processing batch 7, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 686us/step\n", + "Processing batch 8, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 657us/step\n", + "Processing batch 9, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 658us/step\n", + "Processing batch 10, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 662us/step\n", + "Processing batch 11, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 720us/step\n", + "Processing batch 12, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 928us/step\n", + "Processing batch 13, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 834us/step\n", + "Processing batch 14, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 723us/step\n", + "Processing batch 15, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 706us/step\n", + "Processing batch 16, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 714us/step\n", + "Processing batch 17, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 731us/step\n", + "Processing batch 18, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 686us/step\n", + "Processing batch 19, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 960us/step\n", + "Processing batch 20, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 982us/step\n", + "Processing batch 21, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 743us/step\n", + "Processing batch 22, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 732us/step\n", + "Processing batch 23, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 1ms/step \n", + "Processing batch 24, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 862us/step\n", + "Processing batch 25, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 641us/step\n", + "Processing batch 26, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 658us/step\n", + "Processing batch 27, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 651us/step\n", + "Processing batch 28, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 685us/step\n", + "Processing batch 29, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 654us/step\n", + "Processing batch 30, batch shape: (800, 64, 64)\n", + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 640us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-24 19:53:14.437750: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" ] } ], @@ -14388,21 +4934,21 @@ "# val_dataset = val_dataset.batch(800)\n", "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", "train_dataset = train_dataset.batch(800)\n", - "inputs,targets = next(iter(train_dataset))\n", - "outputs = model_builder.model.predict(inputs)\n", + "# inputs,targets = next(iter(train_dataset))\n", + "# outputs = model_builder.model.predict(inputs)\n", "# # Initialize lists to collect the data\n", - "# all_images = []\n", - "# all_true_midpoints = []\n", - "# all_pred_midpoints = []\n", + "all_images = []\n", + "all_true_midpoints = []\n", + "all_pred_midpoints = []\n", "\n", "# # Loop through each batch in the validation dataset, predict, and collect results\n", - "# # for i, (data_batch, midpoints_batch) in enumerate(val_dataset):\n", + "# for i, (data_batch, midpoints_batch) in enumerate(val_dataset):\n", "\n", - "# for i, (data_batch, midpoints_batch) in enumerate(train_dataset):\n", - "# print(f\"Processing batch {i + 1}, batch shape: {data_batch.shape}\")\n", + "for i, (data_batch, midpoints_batch) in enumerate(train_dataset):\n", + " print(f\"Processing batch {i + 1}, batch shape: {data_batch.shape}\")\n", " \n", - "# # Get the model predictions\n", - "# predictions = model_builder.model.predict(data_batch)\n", + " # Get the model predictions\n", + " predictions = loaded_model.predict(data_batch)\n", "\n", "# # Extend the lists to store data from each batch\n", "# all_images.extend(data_batch.numpy()) # Store all images\n", @@ -14437,126 +4983,125 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 22, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "TensorShape([800, 1, 13, 2])" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" + ] } ], "source": [ - "targets.shape" + "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", + "train_dataset = train_dataset.batch(800)\n", + "inputs,targets = next(iter(train_dataset))\n", + "outputs = model_builder.model.predict(inputs)" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", "text/plain": [ - "
" + "((24000, 64, 64), (24000, 1, 5, 2), (24000, 1, 5, 2))" ] }, + "execution_count": 11, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", + "all_images.shape,all_pred_midpoints.shape,all_true_midpoints.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import matplotlib.pyplot as plt\n", "\n", - "def visualize_midpoints(image, midpoints):\n", - " \"\"\"\n", - " Visualizes midpoints on an image without using a probability vector.\n", + "# def visualize_midpoints(image, midpoints):\n", + "# \"\"\"\n", + "# Visualizes midpoints on an image without using a probability vector.\n", "\n", - " Parameters:\n", - " - image: A 3D tensor representing the image.\n", - " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + "# Parameters:\n", + "# - image: A 3D tensor representing the image.\n", + "# - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", "\n", - " Returns:\n", - " None (displays the image with midpoints).\n", - " \"\"\"\n", - " # Convert to NumPy arrays for easier handling\n", - " image_np = image\n", - " midpoints_np = midpoints\n", + "# Returns:\n", + "# None (displays the image with midpoints).\n", + "# \"\"\"\n", + "# # Convert to NumPy arrays for easier handling\n", + "# image_np = image\n", + "# midpoints_np = midpoints\n", "\n", - " # Denormalize image if necessary (adjust based on your normalization method)\n", - " denormalized_image = image_np # Modify if normalization was applied during training\n", + "# # Denormalize image if necessary (adjust based on your normalization method)\n", + "# denormalized_image = image_np # Modify if normalization was applied during training\n", "\n", - " # Visualize the image\n", - " plt.figure(figsize=(4, 4))\n", - " plt.imshow(denormalized_image, cmap='gray')\n", - " plt.title(\"Predicted Midpoint Visualization\")\n", + "# # Visualize the image\n", + "# plt.figure(figsize=(4, 4))\n", + "# plt.imshow(denormalized_image, cmap='gray')\n", + "# plt.title(\"Predicted Midpoint Visualization\")\n", "\n", - " # Plot midpoints directly\n", - " for i, (x, y) in enumerate(midpoints_np):\n", - " plt.scatter(x, y, color='red', s=5)\n", + "# # Plot midpoints directly\n", + "# for i, (x, y) in enumerate(midpoints_np):\n", + "# plt.scatter(x, y, color='red', s=5)\n", "\n", - " plt.show()\n", + "# plt.show()\n", "\n", - "def visualize_midpoints2(image, midpoints):\n", - " \"\"\"\n", - " Visualizes ground truth midpoints on an image without using a probability vector.\n", + "# def visualize_midpoints2(image, midpoints):\n", + "# \"\"\"\n", + "# Visualizes ground truth midpoints on an image without using a probability vector.\n", "\n", - " Parameters:\n", - " - image: A 3D tensor representing the image.\n", - " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", + "# Parameters:\n", + "# - image: A 3D tensor representing the image.\n", + "# - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", "\n", - " Returns:\n", - " None (displays the image with midpoints).\n", - " \"\"\"\n", + "# Returns:\n", + "# None (displays the image with midpoints).\n", + "# \"\"\"\n", " \n", - " image_np = image\n", - " midpoints_np = midpoints\n", - " denormalized_image = image_np \n", + "# image_np = image\n", + "# midpoints_np = midpoints\n", + "# denormalized_image = image_np \n", "\n", - " # Visualize the image\n", - " plt.figure(figsize=(4, 4))\n", - " plt.imshow(denormalized_image, cmap='gray')\n", - " plt.title(\"Ground Truth Midpoint Visualization\")\n", + "# # Visualize the image\n", + "# plt.figure(figsize=(4, 4))\n", + "# plt.imshow(denormalized_image, cmap='gray')\n", + "# plt.title(\"Ground Truth Midpoint Visualization\")\n", "\n", - " # Plot midpoints directly\n", - " for i, (x, y) in enumerate(midpoints_np):\n", - " plt.scatter(x, y, color='red', s=5)\n", + "# # Plot midpoints directly\n", + "# for i, (x, y) in enumerate(midpoints_np):\n", + "# plt.scatter(x, y, color='red', s=5)\n", "\n", - " plt.show()\n", + "# plt.show()\n", "\n", - "# Example usage with random data\n", - "t = np.random.randint(0, 800)\n", - "# t=100\n", + "# # Example usage with random data\n", + "# t = np.random.randint(0, 800)\n", + "# # t=100\n", "\n", - "visualize_midpoints(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(outputs[t,0,:,:])*64)\n", - "visualize_midpoints2(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(targets[t,0,:,:])*64)\n" + "# visualize_midpoints(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(outputs[t,0,:,:])*64)\n", + "# visualize_midpoints2(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(targets[t,0,:,:])*64)\n" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 68, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -14566,7 +5111,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -14587,46 +5132,76 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 78, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "code to visualize Josh's edit" + "loaded_model.loss(5)(train_midpoints,all_pred_midpoints)" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ - "# model_builder.model.save('/home/da886/Electron Counting Extended Arch/Overfitted weights/increased_model_Padded_weights.keras')" + "@tf.keras.utils.register_keras_serializable()\n", + "def custom_loss(exponent):\n", + " def loss(y_true, y_pred):\n", + " diff = tf.abs(y_true - y_pred)\n", + " powered_diff = tf.pow(diff, exponent)\n", + " return tf.reduce_mean(powered_diff)\n", + " return loss" ] }, { "cell_type": "code", - "execution_count": 268, + "execution_count": 73, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 193ms/step - loss: 0.0136\n" + "Computed loss: 0.00027698426856659353\n" ] } ], "source": [ - "val_loss = model_builder.model.evaluate(val_dataset)" + "dynamic_exponent_callback = DynamicExponentCallback(1, 1, 50)\n", + "loss_fn = dynamic_exponent_callback.custom_loss(exponent=4)\n", + "\n", + "\n", + "\n", + "y_true = train_midpoints # Ground truth\n", + "y_pred = all_pred_midpoints # Predictions\n", + "\n", + "\n", + "computed_loss = loss_fn(y_true, y_pred)\n", + "\n", + "print(f\"Computed loss: {computed_loss.numpy()}\")" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 54, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -14636,7 +5211,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -14657,7 +5232,7 @@ "\n", "# Loop through each prediction to calculate the MSE\n", "for i in range(len(all_pred_midpoints)):\n", - " mse = np.mean((all_pred_midpoints[i] - all_true_midpoints[i]) ** 2)\n", + " mse = np.mean((all_pred_midpoints[i] - all_true_midpoints[i]) **8)\n", " \n", " if mse < min_mse:\n", " min_mse = mse\n", @@ -14741,7 +5316,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/Model Training(Fixed)Experimental 13.ipynb b/Model Training(Fixed)Experimental 13.ipynb deleted file mode 100644 index 4990308..0000000 --- a/Model Training(Fixed)Experimental 13.ipynb +++ /dev/null @@ -1,3834 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# import os\n", - "# import tensorflow as tf\n", - "\n", - "# # Set CUDA device order and visible devices\n", - "# os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n", - "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2,3,4,5,6,7,8,9\"\n", - "\n", - "# # Set the device\n", - "# device = '/cpu:0'\n", - "# if tf.config.experimental.list_physical_devices('GPU'):\n", - "# try:\n", - "# # Restrict TensorFlow to only use the second GPU\n", - "# gpus = tf.config.experimental.list_physical_devices('GPU')\n", - "# if gpus:\n", - "# tf.config.experimental.set_visible_devices(gpus[9], 'GPU')\n", - "# device = '/gpu:9'\n", - "# except RuntimeError as e:\n", - "# print(e)\n", - "\n", - "# print(\"device\", device)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:46:58.366157: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2024-09-19 21:46:58.379137: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2024-09-19 21:46:58.391952: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2024-09-19 21:46:58.395802: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "2024-09-19 21:46:58.407058: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2024-09-19 21:46:59.127581: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1', '/job:localhost/replica:0/task:0/device:GPU:2')\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:47:00.874705: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n", - "2024-09-19 21:47:00.876166: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 79196 MB memory: -> device: 1, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:46:00.0, compute capability: 8.0\n", - "2024-09-19 21:47:00.877476: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 79196 MB memory: -> device: 2, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:49:00.0, compute capability: 8.0\n" - ] - } - ], - "source": [ - "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2\" # Only GPUs 0 and 1 will be visible to TensorFlow\n", - "\n", - "import tensorflow as tf\n", - "strategy = tf.distribute.MirroredStrategy(devices=[\"/gpu:0\", \"/gpu:1\",\"/gpu:2\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import h5py\n", - "from sklearn.model_selection import train_test_split\n", - "from tensorflow.keras import layers, callbacks\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# -----------------------------\n", - "# DataLoader Class Definition\n", - "# -----------------------------\n", - "class DataLoader:\n", - " def __init__(self, h5_filename):\n", - " self.h5_filename = h5_filename\n", - " self.images, self.centers = self.load_data()\n", - "\n", - " def load_data(self):\n", - " with h5py.File(self.h5_filename, 'r') as f:\n", - " images = np.array(f['images'])\n", - " centers = np.array(f['centers_training'])\n", - " return images, centers\n", - "\n", - " def plot_image_with_centers(self, image_index=None):\n", - " if image_index is None:\n", - " image_index = np.random.randint(0, len(self.images))\n", - "\n", - " image = self.images[image_index]\n", - " centers = self.centers[image_index]\n", - "\n", - " plt.imshow(image, cmap='gray')\n", - " valid_centers = centers[centers[:, 0] == 1]\n", - " for center in valid_centers:\n", - " plt.scatter(center[1], center[2], c='red', marker='x') # center[1] is x and center[2] is y\n", - " plt.title('Image with Valid Centers Marked')\n", - " plt.colorbar()\n", - " plt.show()\n", - "\n", - " @staticmethod\n", - " def sort_centers(centers):\n", - " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", - "\n", - " def normalize_data(self):\n", - " normalized_images = self.images / np.max(self.images)\n", - " sorted_centers = np.array([self.sort_centers(image_centers[:, 1:]) for image_centers in self.centers])\n", - " normalized_centers = sorted_centers / 64\n", - "\n", - " normalized_midpoints = tf.expand_dims(normalized_centers, axis=1)\n", - " return normalized_images, normalized_midpoints.numpy()\n", - "\n", - " def split_data(self, train_size=0.8, random_state=42):\n", - " normalized_images, normalized_midpoints_np = self.normalize_data()\n", - " return train_test_split(normalized_images, normalized_midpoints_np, train_size=train_size, random_state=random_state)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# -----------------------------\n", - "# Utility Function Definition\n", - "# -----------------------------\n", - "def plot_transposed_images_with_midpoints(dataset, image_indices=[0, 1, 2, 3]):\n", - " \"\"\"\n", - " Extracts multiple images and their midpoints from the given dataset, transposes the images, \n", - " corrects the midpoints, and plots the transposed images with the corrected midpoints.\n", - "\n", - " Args:\n", - " - dataset (tf.data.Dataset): The dataset from which to extract the images and midpoints.\n", - " - image_indices (list): The indices of the images in the batch to visualize. Default is [0, 1, 2, 3].\n", - " \"\"\"\n", - "\n", - " # Extract a sample image batch and its corresponding midpoints from the dataset\n", - " sample_image_batch, sample_midpoints_batch = next(iter(dataset))\n", - "\n", - " # Create a figure with 2x2 subplots\n", - " fig, axes = plt.subplots(2, 2, figsize=(6, 6))\n", - "\n", - " for i, ax in enumerate(axes.flat):\n", - " if i < len(image_indices):\n", - " # Select the specified image and corresponding midpoints from the batch\n", - " sample_image = np.array(sample_image_batch[image_indices[i]])\n", - " sample_midpoints = np.array(sample_midpoints_batch[image_indices[i]])\n", - "\n", - " # Transpose the image\n", - " transposed_image = sample_image.T\n", - "\n", - " # Correct the midpoints by swapping the x and y coordinates\n", - " transposed_midpoints_corrected = sample_midpoints[:, :, [1, 0]]\n", - "\n", - " # Plot the transposed image with corrected midpoints\n", - " ax.imshow(transposed_image, cmap='gray')\n", - " ax.scatter(\n", - " transposed_midpoints_corrected[:, :, 0] * 64, \n", - " transposed_midpoints_corrected[:, :, 1] * 64, \n", - " c='red', marker='o', s=5\n", - " )\n", - " ax.set_title(f'Image {image_indices[i]} for this batch')\n", - " else:\n", - " ax.axis('off') # If fewer than 4 images are requested, hide the unused subplots\n", - "\n", - " plt.tight_layout()\n", - " plt.show()\n", - "\n", - "# -----------------------------\n", - "# Custom Loss and Callback Definitions\n", - "# -----------------------------\n", - "@tf.keras.utils.register_keras_serializable()\n", - "def custom_loss(exponent):\n", - " def loss(y_true, y_pred):\n", - " diff = tf.abs(y_true - y_pred)\n", - " powered_diff = tf.pow(diff, exponent)\n", - " return tf.reduce_mean(powered_diff)\n", - " return loss\n", - "\n", - "@tf.keras.utils.register_keras_serializable()\n", - "class DynamicExponentCallback(tf.keras.callbacks.Callback):\n", - " def __init__(self, initial_exponent, increment, update_frequency):\n", - " super().__init__()\n", - " self.exponent = initial_exponent\n", - " self.increment = increment\n", - " self.update_frequency = update_frequency\n", - "\n", - " def on_epoch_end(self, epoch, logs=None):\n", - " if (epoch + 1) % self.update_frequency == 0:\n", - " self.exponent += self.increment\n", - " print(f\"\\nEpoch {epoch + 1}: Increasing exponent to {self.exponent}\")\n", - " self.model.loss = self.custom_loss(self.exponent)\n", - "\n", - " def custom_loss(self, exponent):\n", - " def loss(y_true, y_pred):\n", - " diff = tf.abs(y_true - y_pred)\n", - " powered_diff = tf.pow(diff, exponent)\n", - " return tf.reduce_mean(powered_diff)\n", - " return loss\n", - "\n", - " def get_config(self):\n", - " config = super().get_config().copy()\n", - " config.update({\n", - " 'initial_exponent': self.exponent,\n", - " 'increment': self.increment,\n", - " 'update_frequency': self.update_frequency,\n", - " })\n", - " return config\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "My model" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# class ModelBuilder:\n", - "# def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=1e-3, weights_path=None):\n", - "# self.input_shape = input_shape\n", - "# self.num_classes = num_classes\n", - "# self.num_coordinates = num_coordinates\n", - "# self.learning_rate = learning_rate\n", - "# self.model = self.build_model()\n", - "\n", - "# # Load weights if a path is provided\n", - "# if weights_path is not None:\n", - "# self.model.load_weights(weights_path)\n", - "\n", - "# self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", - "# # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", - "\n", - "# def build_model(self):\n", - "# x_input = layers.Input(shape=self.input_shape)\n", - "# x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x_input)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.BatchNormalization()(x)\n", - "# x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x)\n", - " \n", - "# x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.Dropout(0.05)(x)\n", - "# x = layers.BatchNormalization()(x)\n", - " \n", - " \n", - "# x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.Dropout(0.05)(x)\n", - "# x = layers.BatchNormalization()(x)\n", - " \n", - " \n", - "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.Dropout(0.1)(x)\n", - "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.Dropout(0.1)(x)\n", - " \n", - "# x = layers.Conv2D(256, kernel_size=5, padding='same', activation='relu')(x)\n", - "# x = layers.MaxPool2D()(x)\n", - "# x = layers.BatchNormalization()(x)\n", - "# # x = layers.Dropout(0.1)(x)\n", - " \n", - "# x = layers.Flatten()(x)\n", - " \n", - " \n", - " \n", - "# x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", - "# x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", - " \n", - "# return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", - "\n", - "# def compile_model(self, loss_function):\n", - "# self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", - "\n", - "# def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", - "# history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", - "# return history\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Josh's model" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "class ModelBuilder:\n", - " def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=1e-2, weights_path=None):\n", - " self.input_shape = input_shape\n", - " self.num_classes = num_classes\n", - " self.num_coordinates = num_coordinates\n", - " self.learning_rate = learning_rate\n", - " self.model = self.build_model()\n", - "\n", - " # Load weights if a path is provided\n", - " if weights_path is not None:\n", - " self.model.load_weights(weights_path)\n", - "\n", - " self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", - " # self.optimizer =tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n", - "\n", - " def build_model(self):\n", - " x_input = layers.Input(shape=self.input_shape)\n", - " \n", - " x_1 = layers.Conv2D(32, kernel_size=6, padding='same', activation='relu')(x_input)\n", - " x_2 = layers.Conv2D(32, kernel_size=8, padding='same', activation='relu')(x_input)\n", - " x_3 = layers.Conv2D(64, kernel_size=19, padding='same', activation='relu')(x_input)\n", - " \n", - " x = layers.concatenate([x_1, x_2, x_3])\n", - " x = layers.Flatten()(x)\n", - " \n", - " x = layers.Dense(64, activation='relu')(x)\n", - " # x = layers.Dropout(0.1)(x)\n", - " x = layers.Dense(32, activation='relu')(x)\n", - " # x = layers.Dropout(0.1)(x)\n", - " x = layers.Dense(16, activation='relu')(x)\n", - " \n", - " x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", - " x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", - " \n", - " return tf.keras.models.Model(x_input, x_midpoints_reshape)\n", - "\n", - " def compile_model(self, loss_function):\n", - " self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", - "\n", - " def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", - " history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", - " return history\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# -----------------------------\n", - "# Main Script Execution\n", - "# -----------------------------\n", - "\n", - "# Load data\n", - "h5_filename = '/home/da886/Final Electron counting project/Images and Labels/1milFixed_Mixed_5.h5' \n", - "\n", - "data_loader = DataLoader(h5_filename)\n", - "images, centers = data_loader.load_data()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGfCAYAAAAZGgYhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA0fUlEQVR4nO3df3DdVZ3/8ddNk9yWtrmhpSSttLWOlYLYAgVKLK4I0Q5fhy1LcdHB2a7LyMCmSFt3lO4I6I5LWBgF0VKEdQFnZbt2ZwrifoFlioRVQ6EBRn4stWjHZi1Jdb82CYHepr3n+wdy15Bzat7N+fTcmz4fM3cGPvfTc8/nx73vfO7nfd/vnHPOCQCAI6wm9QQAAEcnAhAAIAkCEAAgCQIQACAJAhAAIAkCEAAgCQIQACAJAhAAIAkCEAAgCQIQACCJ2qwGXr9+vW655Rb19PRo0aJF+uY3v6mzzjrrj/67Uqmk3bt3a+rUqcrlcllNDwCQEeecBgYGNGvWLNXUHOI6x2Vg48aNrr6+3v3TP/2Te+mll9xnP/tZ19jY6Hp7e//ov+3u7naSePDgwYNHlT+6u7sP+Xmfcy5+MdIlS5bozDPP1Le+9S1Jb13VzJ49W1dffbWuvfbaQ/7bvr4+NTY26hz9H9WqblSvl6urH7HMDe23T9xjwrRjRyw7+P9+F2XsIN+VX+Aw5Wr9F7Hu4EH/2OOt9mzoKjnCdvrOKylwbhnnYRo7NL51Gy3fKATGrpmY9y4v7Sva5mKR4TGOxfc+dAcOZPuahs+94OeEYY6hMXwOuCH958EfaO/evSoUCsH1on8Ft3//fnV1dWndunXlZTU1NWptbVVnZ+eI9YvFoorF/z15BwYGfj+xOtXmRhmAPOu5XJyTc0LNyIPse72ovG+4wAdZLnBi5UKXvZXzpo0i+KEaIQAFjrP33DLOwzR2cPwMA1Bg7JqcP3CWciXbXCwyPMax+N6HLuNbCJbPvfDnxOjnGBrj0P/m0ONHT0L47W9/q4MHD6qpqWnY8qamJvX09IxYv729XYVCofyYPXt27CkBACpQ8iy4devWqa+vr/zo7u5OPSUAwBEQ/Su44447ThMmTFBvb++w5b29vWpubh6xfj6fVz4/8nvlmsnHjLjcLw0Oel/T971nzcSJ3nVL+/b5Jx64VDTd70nwXXXoO9zQ9ruDI78qiXW/LFMx9q11DGf4Wsl6j866z2OcQ6ExDF/DhN4/Me5FxrhPERK853ZgyP8PjPvbdC/Fev8v9JqG9WPsQ8sYzo1u3ehXQPX19Vq8eLG2bNlSXlYqlbRlyxa1tLTEfjkAQJXK5HdAa9eu1cqVK3XGGWforLPO0m233abBwUF95jOfyeLlAABVKJMAdOmll+o3v/mNrr/+evX09OjUU0/VI488MiIxAQBw9MqsEsKqVau0atWqrIYHAFS55FlwAICjU2ZXQGNVGnxDpVwgQ+UdfFklpaL/l9mZZsNkWa3AmMEV2v4o2VQRMtLMxyHGXKyZTYHjY/nVe2h5aPtzE/x/E5oykKwZT579UjN1qnfV0u9/KD7q1zRk2FnnHcx09Zz7wQoBkTLSLKKNnWV1DMM4NZMnj1zm9kv+pOXh6436VQAAiIgABABIggAEAEiCAAQASKJikxB8zOV1fELlVSxlSowlTaKUZTfeXMzVBqotx7gBmmUZ/AoqsR+ai/d4RirDZE1miMIz91CygVmGpZJM7/uAWAkBlsQUc8mhLKtqGxKnQvMrvfHGyGVudMlEXAEBAJIgAAEAkiAAAQCSIAABAJIgAAEAkqjcLLhcbkT2R5SmT9ZSLxFK8YSYsmGMGUJZlhKJkcVjPQ5ZNxQzzcWXIRQqqxSQoglgjIZvWTaNM79/LGV0YjWLjJDpaj1XMs0MNWyP6diPcs5cAQEAkiAAAQCSIAABAJIgAAEAkiAAAQCSqNgsuNyECcrlJgxbZso0qaAsoxBLrShz5kyGYmQ85SZM8C4Pjm2t4WeZizGza8wZQofDUJMwy7mYxwhkWfmOv6lBo9K8x6NkpFVBvUPvqhnUI+QKCACQBAEIAJAEAQgAkAQBCACQBAEIAJBExWbBuQMH5N6RQRPsiFosegY48pkmsbJETLXgjHz1s8zZRKHMJkMX1lDGk6m+VyTW42bZh7Ey0mry+RHLQh1BrZ01vRlpsbp5WrrKBmSZ1RdrbEsHUfwvroAAAEkQgAAASRCAAABJEIAAAElUbBKCjzfZwKgabmj6bhYHS9ekaIRmLY1iKCMTajCXaambGM3+IiWJhPgSDoKln3L+vytDx8d7DkVovHaocY50CZiaY47xLi8NDo55bKmCEg6s52HiskBcAQEAkiAAAQCSIAABAJIgAAEAkiAAAQCSqKosuGDGhiHzI8tslWhje7YzRrkYKduSNqZMNWt2VCCzK4oMm4ylyI4yZSMGB7G910JZmsGMPE+2oznT03DcYmW7hZiaSGaZeZYiq817TuSkUUyFKyAAQBIEIABAEgQgAEASBCAAQBIEIABAEhWbBZerrVUuN3x6MbJKQtlhciX/4kqp8RRgzXbzrh9p202N0IzZOllm78WoV5aC+dy0bI+xpliM90mW77UUWaFmMc5D4xjBz0PfEKF95Rt7lHPmCggAkAQBCACQBAEIAJAEAQgAkAQBCACQhDkAPfnkk7rwwgs1a9Ys5XI5PfDAA8Oed87p+uuv18yZMzVp0iS1trZqx44d5om5gwdHPHITJngfXrmc9+GG9vsfBw54Hz41Eyd6H7Hk6upHPEJC25OrrfU+vOt79vWhOq2Gxg5P0o18pBA4J7zzq7Q5HumxQ/sky30Vmp/x4Xv/hN4nwal4xrBkjEmy7yvr+r5tt3xGKvz54Q4MjXhkwRyABgcHtWjRIq1fv977/M0336zbb79dd955p7Zu3arJkydr2bJl2udpKQwAOHqZfwd0wQUX6IILLvA+55zTbbfdpi996Utavny5JOm73/2umpqa9MADD+iTn/zkiH9TLBZVLBbL/9/f32+dEgCgCkW9B7Rz50719PSotbW1vKxQKGjJkiXq7Oz0/pv29nYVCoXyY/bs2TGnBACoUFEDUE9PjySpqalp2PKmpqbyc++0bt069fX1lR/d3d0xpwQAqFDJS/Hk83nl8/nU0wAAHGFRA1Bzc7Mkqbe3VzNnziwv7+3t1amnnmobzDm9s6VeKCvN0o3Q1LUzsH4p44QKS32qGLXgrPWwUtTHq5k82bvc1OkyQWab9XyzCGVeBs/PCB2Fa445xv+aMTqOhuqVGfehKWMrsO0pasSZz5UInZOjqJSOqPPmzVNzc7O2bNlSXtbf36+tW7eqpaUl5ksBAKqc+Qro9ddf16uvvlr+/507d+r555/XtGnTNGfOHK1evVpf/epXNX/+fM2bN0/XXXedZs2apYsuuijmvAEAVc4cgLZt26aPfOQj5f9fu3atJGnlypW699579YUvfEGDg4O64oortHfvXp1zzjl65JFHNDHiDzUBANUv51xlNT3p7+9XoVDQuVqu2lzdqP6N6R5Q4FfBpvtLFdQjKMU9oBSi3ANKwPy9vqGfi/keUEil3AMKiLIPrfe/jB+LMT4nsrxfaDbGfXjADekJ94D6+vrU0NAQfJnkWXAxmA5Q7siXvwuWqQnNxdMgznrDNXgy+4JNhm9CKTB3Y3mZTANNYC7WP1ZM60ZoHBbtg8lwnFME/EOVhfL/A8/2ZNx0sNIb8plZ9gsN6QAA1YYABABIggAEAEiCAAQASIIABABIonKz4HzNsmJkrHgyzA65ui8Dx5hRk2l2SzA1MvC3RazmZr6pWLYzUtmVGKmrMbLdzIznsilVPuOMr8zEmrclhTiWCK9pzZaN8fOJ4M84fNm1GexDroAAAEkQgAAASRCAAABJEIAAAEkQgAAASVRuFpynIV2QIQPFnNkUIfMjSiFNc+ZdoClXjO2ZOtW7vDQw4F1uKdQYzGoL1AMLjeMr1FkqFr3rxqgPGCwMGnpNY3FMX6ZesEZalhlf1kw1y/rWrDFjIV7/IHG2x3t8jJ81KWrBmZpfZlAslSsgAEASBCAAQBIEIABAEgQgAEASBCAAQBKVmwXnYc2Q8o4RIXPGmg0So4ukvZW4v515jPpRoWy3YIZQPj9yHqF9ZW0nHWAZx7pPfOdQrHmbsjczrOsXK+Mpyzp7KbLdKj7DMMP5ZZGlxxUQACAJAhAAIAkCEAAgCQIQACCJqkpCCN4EM9yMjXET3jyPCDcGzWU9QtsZ48alcTt9SRjRynoY5mJ+zcDYKZrDWcoZxfDgrzq9y//0hLP8/yDDm9/W4+YtwxRKEol0fL726n+OWPb5+R/2Dx06fyq9YWCIdx/mRlVJjSsgAEASBCAAQBIEIABAEgQgAEASBCAAQBJVlQWXojyGKfsoMI8sGjn97+CB8jcRSvEEm6xFKDsTLYPLcOxTNCOMxVJuKoY/fdeZoZmYxgnOO8MmkqbzM9IxXvvuFs9SY4kn6+dEhZyfvnJLOVeSRnHYuAICACRBAAIAJEEAAgAkQQACACRBAAIAJFFVWXBZNlkLidI4y9rEK0LmXZTGc7GarHmEGgOGmGrbSXFqwVWSI7w95uaPoYysLDNUIzSXjCZCjcUodRCtmbjW4+lb1TNv50a3LVwBAQCSIAABAJIgAAEAkiAAAQCSIAABAJKoqiy4GNktofpmoQwU33Jz9o2xhp0lGyZGdot5jOBcRp+laD2WoTkq5/8bKtNMKFP2kS1z05LZFi17z7M9MTI3D2ecGCxZpBWVSWdUk8+PWBbu/Bq41hhltlpWuAICACRBAAIAJEEAAgAkQQACACRhCkDt7e0688wzNXXqVB1//PG66KKLtH379mHr7Nu3T21tbZo+fbqmTJmiFStWqLe3N+qkAQDVz5QF19HRoba2Np155pk6cOCA/vZv/1Yf+9jH9PLLL2vy5MmSpDVr1ujf//3ftWnTJhUKBa1atUoXX3yxfvKTn9hmlsuNzM6JUFcqlCUSyuLxZ9QM2V7UOu8Mu0WahOYdyOozZQEmqJMVa1/5OkDGGjtJXboI76sU8w5mEhrqDJrfy8GBjnztwVKxOOp1KzWrL+fc4Z99v/nNb3T88cero6NDf/Inf6K+vj7NmDFD999/vy655BJJ0iuvvKKTTjpJnZ2dOvvss//omP39/SoUCjo3d5Fqc+9IYT3CrbdDYhTwO/Rkxv6BbXo56xvF2hr9CG9P1q95tKT5VivfPo/1EwnTPLJOTU/xvhqlA25IT+hB9fX1qaGhIbjemO4B9fX1SZKmTZsmSerq6tLQ0JBaW1vL6yxYsEBz5sxRZ2end4xisaj+/v5hDwDA+HfYAahUKmn16tVaunSpTjnlFElST0+P6uvr1djYOGzdpqYm9fT0eMdpb29XoVAoP2bPnn24UwIAVJHDDkBtbW168cUXtXHjxjFNYN26derr6ys/uru7xzQeAKA6HFYpnlWrVumHP/yhnnzySZ1wwgnl5c3Nzdq/f7/27t077Cqot7dXzc3N3rHy+bzynpISb32XeeS+z8zyJqr1u2DfTe7QGMGkCsuN2Ky/H0/xvXSM1wwlWxjOlYppjiZVzP2BoEjz9u3zUAkua1KS6diH3t8ZNvvL/H5uZKYrIOecVq1apc2bN+vxxx/XvHnzhj2/ePFi1dXVacuWLeVl27dv165du9TS0hJnxgCAccF0BdTW1qb7779fDz74oKZOnVq+r1MoFDRp0iQVCgVdfvnlWrt2raZNm6aGhgZdffXVamlpGVUGHADg6GEKQBs2bJAknXvuucOW33PPPfrLv/xLSdKtt96qmpoarVixQsViUcuWLdMdd9wRZbIAgPHDFIBG85OhiRMnav369Vq/fv1hTwoAMP5RCw4AkERVNaRLwvJr41DWlLGxm6X5WDDbzZVGPXZ4IqEma5XTfCzEl/UUbtZlywTy7vPA/jY3zIuRlZRh6adMZfiawbI1ETIdraJVUolRbsrwWebLzj2s1/wDXAEBAJIgAAEAkiAAAQCSIAABAJIgAAEAkjjqsuBSZI1lKctaY5Z6ctFeM1KGnaVZl3kuWdZ3q/Dss2DfLGu2n2XsgCjvzVDWYTXIsN6hb+wsMgO5AgIAJEEAAgAkQQACACRBAAIAJEEAAgAkMT6y4CyZLDGy3awi1BoLZRNZuyv66jmF1jXXKwsx1Bozd5EMHbcItdOinBOxOk5mWa8twvGJwTy26X0/+q6iUsTOor5VQzXVYtWIs0jcJZcrIABAEgQgAEASBCAAQBIEIABAEgQgAEASVZUFF6NOWJKuncZME1/2WawaaZWU7WcRI/soSuaZdZxYWUYVkglVUd1wLd08A3UNQ5mewYy0COdblHM5tH6Kc3wMuAICACRBAAIAJEEAAgAkQQACACRRVUkIoZt3NZMnj1hWeuONwCCjL38jxWmoFeMGbawyJbnaupFjWxusJS7fMUyERmMxjn3mfDfWPcdSynbeSZINrDfKfc3UQqWsKunYW99XGSaP+Na3JU/kpFFMjysgAEASBCAAQBIEIABAEgQgAEASBCAAQBJVlQUXyoYpDQ6OeegYWS8VVeYmWAZkKLvXrCSGOSbJeDJkKUryNlK0zvvR3c97ly+bdappHK8I50qmZX4C8zMf+2p+TxgESxF5+Brs5VxJGsVh4woIAJAEAQgAkAQBCACQBAEIAJAEAQgAkER1ZcGF6rj56haFsjhiNGwyzEOyN6CqyedHLCvt2+cfI8RSCy0w75AYWUmZ1+CyHLcs52LMmgpmKUbIslr2rtMCz0TI4DLW5PNlTmWaRZpxY0BT7bQMRcsktGSResZ2bnSvxxUQACAJAhAAIAkCEAAgCQIQACAJAhAAIInqyoILsGR4BLNEImTNWboLHoov461m4kT/ax4cWSPsrbn4s6midESNIPPXrJRacNaOrVnWFDNkAUbrIBrM9jvCGWIZ7+8knWI9gp9BldT59Q9wBQQASIIABABIggAEAEiCAAQASMIUgDZs2KCFCxeqoaFBDQ0Namlp0cMPP1x+ft++fWpra9P06dM1ZcoUrVixQr29vYc1sVxt7YhHcCMmThzxCI6bz3sfcs7/iMAdOGB65OrqRzxK+/Z5H25ov/cRnsvQiEcsvmNmTcCwjhFa3/KoJL5jH7qBHI0rjXyEVjWeb1kyHc/Q+zuX8z+qlPkcN2x/8Nwcwz40BaATTjhBN910k7q6urRt2zadd955Wr58uV566SVJ0po1a/TQQw9p06ZN6ujo0O7du3XxxRdbXgIAcJTIOTe2P/OnTZumW265RZdccolmzJih+++/X5dccokk6ZVXXtFJJ52kzs5OnX322aMar7+/X4VCQR+pXaHa3PCU4VCKoe+KJ1S8s2byZO/yGG29Y7GkxYYHMfwVF+lKL0YhROsYMa5gkqTQGltyZ3mVUSmFNK2iFN4cZy22g++HnP9aw1L8NpjK7RnjgBvSE+4B9fX1qaGhwf8aGsM9oIMHD2rjxo0aHBxUS0uLurq6NDQ0pNbW1vI6CxYs0Jw5c9TZ2Rkcp1gsqr+/f9gDADD+mQPQCy+8oClTpiifz+vKK6/U5s2bdfLJJ6unp0f19fVqbGwctn5TU5N6enqC47W3t6tQKJQfs2fPNm8EAKD6mAPQiSeeqOeff15bt27VVVddpZUrV+rll18+7AmsW7dOfX195Ud3d/dhjwUAqB7mL9Dr6+v13ve+V5K0ePFiPfPMM/rGN76hSy+9VPv379fevXuHXQX19vaqubk5OF4+n1fe04DNHTggN8r7GL77PaHvK0tvvDGqMVPyfd9v/r47QtkVqxj3DYIlkQLnguXeUEXd16igewy+/WIt3ZKiqZ/l/p/1fWJVMedb6F7Pkb6HPMr9OubfAZVKJRWLRS1evFh1dXXasmVL+bnt27dr165damlpGevLAADGGdMV0Lp163TBBRdozpw5GhgY0P33368nnnhCjz76qAqFgi6//HKtXbtW06ZNU0NDg66++mq1tLSMOgMOAHD0MAWgPXv26C/+4i/02muvqVAoaOHChXr00Uf10Y9+VJJ06623qqamRitWrFCxWNSyZct0xx13ZDJxAEB1G/PvgGJ7+3dA52r5iN8BWVhy1t96oqJ2wwhRfvOgbO8BRWH9FXroXlelfCdvVCll86vhHlCN596x5D/OWR/7Sjnfoh0Hzz63/EbtgBvSE3owu98BAQAwFpVVCCui4F9qCX6tH6pNVyoW/S/g+as+2l9Th6jzVRGqtEFY8BgHKnKEBP9S9V0FGK7+JNs+CX5TEMpGjPB+s87butzEWCGhUq6uo10p+z6DMrgK5woIAJAEAQgAkAQBCACQBAEIAJAEAQgAkERVZcGFMo0sef+Z1isLsGZCxfhNQazfDcUw7n4j4WE9xiFRMtiM56d/EH+2lzmj0/KSxnMi03Oown8XaBaj71EGvZO4AgIAJEEAAgAkQQACACRBAAIAJEEAAgAkUblZcLnciKyLGJlGlZQdVjN1qnd56fXXR65rrDVmqm2XcQXmGPs2SnZYrK6QGWZIZZnBZtme0P4217Yzdrj1D5JhRlqsYxyhVl9IcB9a5hhjH2ZwHLgCAgAkQQACACRBAAIAJEEAAgAkUblJCM5JGt1NL0upl+BN6wxvioZu8pcGBvzre7YnVqkXnyQtuTO+wR+j9bilBbFV6JwIiXKMrMkJlnVDY8c4ntY27b4hMjyWbw00+u2MlvBkSHywHjfLZ6pv3Zxz0ig2kysgAEASBCAAQBIEIABAEgQgAEASBCAAQBKVmwV3hNVMmeJd7t58c+Qya+MsY6aNt/RGIIslN2HC6MeQomQlRSlnZJyHtURNjOwm0xjGLKNMMw8jZKqlKE0VFOGczTrTM0nTRd9+sX5OWLKFA2N7G4K60W07V0AAgCQIQACAJAhAAIAkCEAAgCQIQACAJKoqCy7LxmmhumwW0ZrdWepKZZjtFnxN4/bEqMuWaVOyEEMNMmuWUaYyrL9m3k5DRp616WIMsd6zldJ0MSTK/DI4x7kCAgAkQQACACRBAAIAJEEAAgAkQQACACRRuVlwudyYOiGGMkqU88fcKLXDQhlpsTKKvCvbOiD6OkNmXidrwsh97oaMY2SYIRRUSZl3hrlYs0WD7xXfGNYMSMM5Hi3bzbMPQ/MIfR7EeE1Lt9Foc6mg7NfR4AoIAJAEAQgAkAQBCACQBAEIAJBE5SYhOCdp+A01y83yaDfMDDcXw5MJNCVLcAPdsg+DN7MPBDIIAq9ZKhZH/5pZJhsYk1osN9CtDfOyZG6AmOF5mOk5bkjYMJcKsrKUz7LuE0MSU4ySSMH1M0hw4AoIAJAEAQgAkAQBCACQBAEIAJAEAQgAkMSYAtBNN92kXC6n1atXl5ft27dPbW1tmj59uqZMmaIVK1aot7d3rPN8y9vled7xyNXVj3hE49zIR9Z822kdorbW+7BwQ/u9D7MU+3C083BOuQkTvA934ID34RMawyrGOOZjbznfAu/BLPne37m6+jj7KtJxy1TgvPWdm8FjHxjDIsZnyjsddgB65pln9O1vf1sLFy4ctnzNmjV66KGHtGnTJnV0dGj37t26+OKLxzRJAMD4c1gB6PXXX9dll12mu+++W8cee2x5eV9fn77zne/o61//us477zwtXrxY99xzj37605/qqaeeijZpAED1O6wA1NbWpo9//ONqbW0dtryrq0tDQ0PDli9YsEBz5sxRZ2end6xisaj+/v5hDwDA+Gf+Am/jxo169tln9cwzz4x4rqenR/X19WpsbBy2vKmpST09Pd7x2tvb9ZWvfMU6DQBAlTNdAXV3d+uaa67R9773PU2cODHKBNatW6e+vr7yo7u7O8q4AIDKZroC6urq0p49e3T66aeXlx08eFBPPvmkvvWtb+nRRx/V/v37tXfv3mFXQb29vWpubvaOmc/nlc/nD2/2v2fKzIrQ8Cs8kQyzu4yZRlnWJovSSC8g09phRsG6dJ59G2velnGsjecyPfdDDK8ZzKhyJf/iGOd4qAlcin0VQWifmGss+urpZfCZYgpA559/vl544YVhyz7zmc9owYIF+uIXv6jZs2errq5OW7Zs0YoVKyRJ27dv165du9TS0hJv1gCAqmcKQFOnTtUpp5wybNnkyZM1ffr08vLLL79ca9eu1bRp09TQ0KCrr75aLS0tOvvss+PNGgBQ9aK3Y7j11ltVU1OjFStWqFgsatmyZbrjjjtivwwAoMrlnKusLzX7+/tVKBR0rparNlc3/MkY38tWw3e7Wf6yPMJ2ZtqzJwFzhQjfd+EJzp8k94Bi9JUJrB/lOBxqLh6xel5VDEPvIMn4njUcywNuSE/oQfX19amhoSE4JLXgAABJVG5HVJ8KyVSz1poz10/zzLEmkPZe2rfPNrZBRV3pZHjlGmN7zPsqwvYE/0oP/gP/2JYrD/O+MlwZpTivQu/Nijr3LSJ1X/Z+xoWyEcewT7gCAgAkQQACACRBAAIAJEEAAgAkQQACACRRXVlwIb6MImPGT+g3BTXHHDNiWWlwcPRzOxRDJpQ12838GxHfutYMruBAFZLVF8peNGb3+OYenLcx28103CL9JiVJZleWv0eL8DutLLMXkzDO23u+ZfD7RK6AAABJEIAAAEkQgAAASRCAAABJjI8kBFP5EtvNRVcsHs6MRjmZCEUgg2P7b6z7zPhpo3f5bz641/SSudo673LfDc0skw1CQgkYNZMn+9cPnCumuVtvThuOW+icePVrS7zL53/xWf9LWktFGWSZbFKtyRNWUcoCxUj6CBQ09a7rnDSK6XEFBABIggAEAEiCAAQASIIABABIggAEAEhifGTBxRCjkVOG7YrNpURC7Yo9rNluwde0ZFNZ91WG2UfRSitFECOzqXF7IKMzQrabtcRTKcss0hBDaa4YZaWszK3HK6QJnqU0Vc6VyIIDAFQuAhAAIAkCEAAgCQIQACAJAhAAIImKzYLL1dYqlxvd9GI0oDrUPEbLmq0SrJ12YMiz0FpTbPQNz4LZUZGab/n2oTmzp4IagZka0iVw3Lc7Mxvbmknna+goZZx5aDknEpw/lZLVFovv3C85z2eYB1dAAIAkCEAAgCQIQACAJAhAAIAkCEAAgCQqNgvOHTggN9o6TYZ6TtZaVlFqwQVYMopC8zZ10DS+ZpQadgrswxS14AKvGer0GDr2WZ4TUbrkZrivrGNbst2C701fVqikmnze/5q+jMRYdRpDEmTTjQdcAQEAkiAAAQCSIAABAJIgAAEAkqjYJASv0E1kT0mb4M320E37GDddMyz/E7oRa72JaimLEypDVEmlREw3rkNJEobmfW+NPfamcSGWfR4s5RSjtFKkBJQoYjSLjFTKqmpVUCmrP8QVEAAgCQIQACAJAhAAIAkCEAAgCQIQACCJ6sqCC2XD+LJ+jKU0rOVYjjTz/CJkDlmzw0xZc7Gyw4wN0vyDVE7Gk+n4hDIjA0JZc77M0HBmpC3zLnjcPOdWlGMZEisLzFDOKdpnh2Huof0dWh5qpHikmi5yBQQASIIABABIggAEAEiCAAQASIIABABIwpQF9+Uvf1lf+cpXhi078cQT9corr0iS9u3bp89//vPauHGjisWili1bpjvuuENNTU3xZjxaxiywmsmTRz90KLslUqZNjIZnwaw5T/aRuaZYQJYZg9aMvIqRZQ0uY702UwPEYEajLfNuvJ0Tsd4rJoZzJUoTRdky3nznSs45aRQvab4Cev/736/XXnut/Pjxj39cfm7NmjV66KGHtGnTJnV0dGj37t26+OKLrS8BADgKmH8HVFtbq+bm5hHL+/r69J3vfEf333+/zjvvPEnSPffco5NOOklPPfWUzj77bO94xWJRxWKx/P/9/f3WKQEAqpD5CmjHjh2aNWuW3vOe9+iyyy7Trl27JEldXV0aGhpSa2tred0FCxZozpw56uzsDI7X3t6uQqFQfsyePfswNgMAUG1MAWjJkiW699579cgjj2jDhg3auXOnPvShD2lgYEA9PT2qr69XY2PjsH/T1NSknp6e4Jjr1q1TX19f+dHd3X1YGwIAqC6mr+AuuOCC8n8vXLhQS5Ys0dy5c/X9739fkyZNOqwJ5PN55fP5w/q3AIDqNaZacI2NjXrf+96nV199VR/96Ee1f/9+7d27d9hVUG9vr/eeUaUpvfHG2AcJZKsEu3ZGyJyJkZWTaQaPbF1YgyqoXlvoePpE27eezLYs6xcGM8wy7fqb4TkRem9au/6GOiofDULZlb66fm50GYpj+h3Q66+/rl/84heaOXOmFi9erLq6Om3ZsqX8/Pbt27Vr1y61tLSM5WUAAOOQ6Qrob/7mb3ThhRdq7ty52r17t2644QZNmDBBn/rUp1QoFHT55Zdr7dq1mjZtmhoaGnT11VerpaUlmAEHADh6mQLQf//3f+tTn/qU/ud//kczZszQOeeco6eeekozZsyQJN16662qqanRihUrhv0QFQCAd8o5V0Ffruut3wEVCgWdq+WqzQX6l2TB0j/I2ssmy3tAGY4dS5Tv+yvI0XAPKNMKDqqcc8J6D8h8z2g8MXxGHnBDesI9oL6+PjU0NATXoxYcACCJ6uqIamH9Cy7DC0Fr/Szv3IO17QJjW7ooZnwV5cuSqZk61btuaWAgymuaOjoau+fG6MAbEqpJWBocHDkP41/pITE61lpFqeMW4VsL6xWN5Uon1vvK0lU22hWqZ+7Bzxrfa45yHlwBAQCSIAABAJIgAAEAkiAAAQCSqK4kBEtigbFZV0jNlCkjlllvlJvTZX2JApYbkYExQjJP2fbMxb35ZpyxA8fTm3BgTUwJrW9IEgkmBOT8f/v5kg2srxkaO3QTOUlKdIxz3DB2iKXx2iF5jk+0JB5rA0zfqsaECO+5kkFiCldAAIAkCEAAgCQIQACAJAhAAIAkCEAAgCQqNwsulxuZ5REjs82YyeHLeItVvsOSmRIjEyYo48KTKZgyuyJkx8UqUukrIST5s7WsJXfC5Zwqo7xMtONjmojx/WN5zVhZlxHKh5kz8o5QyS6ugAAASRCAAABJEIAAAEkQgAAASRCAAABJVGwWXK62Trl3tOQOZlsc4cyUWO16o7TkDtWZs9SIyzjbzZvxFKMhmWTK7MqynXKs2mmW2mThY2yci6XOnCvZxg4w7a8sz89KGjtWdlxGsqgZyRUQACAJAhAAIAkCEAAgCQIQACAJAhAAIImKzYJzQ/vlchVQi8yXaRLISrHWsjJ3Sh3jusG5ZJxNk3l3zVGqlHkciilTL9Zxy7KmWqhTrKeuWCjLKkYNsiwzIN8aaOz7MLSdocxD79wj1bY7Ul1yuQICACRBAAIAJEEAAgAkQQACACRBAAIAJFGxWXCVwpINEsq0CS0vFYuBFx17h9dgZ83Qa8ZgyISKlpUUoU5W5hlSGb1minnHGtuSweYODPmfqJAaabFEqbUWo2u0jMfZO3ZOGsVh4AoIAJAEAQgAkAQBCACQBAEIAJAESQh/RIyyOClKwFgam1nFuPmdebKBZ31z6SNrWRODKE3wYjX1s5RnspbciZEoESGpINq+iiHD0lxBxn0YOm7eocdQJoorIABAEgQgAEASBCAAQBIEIABAEgQgAEASR18WXIIyHZaMEilGGYxIGTUZZoGZWY+bZ31rCaVKL4tjZslgC51XtXX+IQJlZIL73NCQLkq5pdD7IZQdFykLcMzrJnKkzluugAAASRCAAABJEIAAAEkQgAAASZgD0K9//Wt9+tOf1vTp0zVp0iR94AMf0LZt28rPO+d0/fXXa+bMmZo0aZJaW1u1Y8eOqJMGAFQ/U3rW7373Oy1dulQf+chH9PDDD2vGjBnasWOHjj322PI6N998s26//Xbdd999mjdvnq677jotW7ZML7/8siYGmqQdUTGyxqzNnQKZNjX5/OjHMGalmOqbhbJyAsutc/FlPOUm+P/2qfQaduHBj/yXCdZMR9P6wWMfaA4XEniveDPeIjWYszSRtLJmAVYr7z401dMbXUM6UwD6h3/4B82ePVv33HNPedm8efPK/+2c02233aYvfelLWr58uSTpu9/9rpqamvTAAw/ok5/8pOXlAADjmOnPth/84Ac644wz9IlPfELHH3+8TjvtNN19993l53fu3Kmenh61traWlxUKBS1ZskSdnZ3eMYvFovr7+4c9AADjnykA/fKXv9SGDRs0f/58Pfroo7rqqqv0uc99Tvfdd58kqaenR5LU1NQ07N81NTWVn3un9vZ2FQqF8mP27NmHsx0AgCpjCkClUkmnn366brzxRp122mm64oor9NnPflZ33nnnYU9g3bp16uvrKz+6u7sPeywAQPUwBaCZM2fq5JNPHrbspJNO0q5duyRJzc3NkqTe3t5h6/T29pafe6d8Pq+GhoZhDwDA+GdKQli6dKm2b98+bNnPf/5zzZ07V9JbCQnNzc3asmWLTj31VElSf3+/tm7dqquuuirOjCtBpFpOpWJx9ONHyhCyrF8zdap3eWlgwPaSnswpNxSpHpZhv2RZ3ypaFlSG25NpZ80IHWtjva+y7H6aZbabuTOvpRZeKAM0sK9M+9A3j1HOzRSA1qxZow9+8IO68cYb9ed//ud6+umnddddd+muu+6SJOVyOa1evVpf/epXNX/+/HIa9qxZs3TRRRdZXgoAMM6ZAtCZZ56pzZs3a926dfq7v/s7zZs3T7fddpsuu+yy8jpf+MIXNDg4qCuuuEJ79+7VOeeco0ceeaQyfgMEAKgYOecqqzZ4f3+/CoWCztVy1eb8P/oakyzbF0SaS6ZfwRnE+gouy69bUuyXTFXr9lTQV3CZjp1Cgq/gTDzzOOCG9IQeVF9f3yHv61MLDgCQRHU1pMuwGVSURm0ZJgSk+AvO7fMnSZhL2kSYu6+cz1tjl2xzqXQxjnOGV1Gh4xC6OR9c31rSxyLDbxBMVxLW/Z3hcbM2Y7SMMRZcAQEAkiAAAQCSIAABAJIgAAEAkiAAAQCSqK4suAyZMrsy/g2L7zdJKbK6kjTZsjQwi/WSxqw+S8Mza9ZYFIHzM8ZczPMOZCke8Wy/WGV+UmTLxhB6X0Vpxugbe3QN6bgCAgAkQQACACRBAAIAJEEAAgAkUXFJCG/XRj2gIc9NrAxLjIRK9Lgsb/4HkhA8N26znUclOfI3bq3H3rd+eN3AzV+XYSmagBRzyfZ9VUE3+b2s88tye47s2Ad+f079sVrXFReABn5fafnH+r8jn8zyvErx+R7anqMl1vik+Oyw7m/L+kc+zoSlmEuW53KlxJkQ6/yy3J5EYw8MDKhQKASfr7h2DKVSSbt379bUqVM1MDCg2bNnq7u7e1y36u7v72c7x4mjYRsltnO8ib2dzjkNDAxo1qxZqqkJ3+mpuCugmpoanXDCCZLe6rAqSQ0NDeP64L+N7Rw/joZtlNjO8Sbmdh7qyudtJCEAAJIgAAEAkqjoAJTP53XDDTcon8+nnkqm2M7x42jYRontHG9SbWfFJSEAAI4OFX0FBAAYvwhAAIAkCEAAgCQIQACAJAhAAIAkKjoArV+/Xu9+97s1ceJELVmyRE8//XTqKY3Jk08+qQsvvFCzZs1SLpfTAw88MOx555yuv/56zZw5U5MmTVJra6t27NiRZrKHqb29XWeeeaamTp2q448/XhdddJG2b98+bJ19+/apra1N06dP15QpU7RixQr19vYmmvHh2bBhgxYuXFj+5XhLS4sefvjh8vPjYRvf6aabblIul9Pq1avLy8bDdn75y19WLpcb9liwYEH5+fGwjW/79a9/rU9/+tOaPn26Jk2apA984APatm1b+fkj/RlUsQHoX//1X7V27VrdcMMNevbZZ7Vo0SItW7ZMe/bsST21wzY4OKhFixZp/fr13udvvvlm3X777brzzju1detWTZ48WcuWLdO+ffuO8EwPX0dHh9ra2vTUU0/pscce09DQkD72sY9pcHCwvM6aNWv00EMPadOmTero6NDu3bt18cUXJ5y13QknnKCbbrpJXV1d2rZtm8477zwtX75cL730kqTxsY1/6JlnntG3v/1tLVy4cNjy8bKd73//+/Xaa6+VHz/+8Y/Lz42Xbfzd736npUuXqq6uTg8//LBefvllfe1rX9Oxxx5bXueIfwa5CnXWWWe5tra28v8fPHjQzZo1y7W3tyecVTyS3ObNm8v/XyqVXHNzs7vlllvKy/bu3evy+bz7l3/5lwQzjGPPnj1Okuvo6HDOvbVNdXV1btOmTeV1/uu//stJcp2dnammGcWxxx7r/vEf/3HcbePAwICbP3++e+yxx9yHP/xhd8011zjnxs+xvOGGG9yiRYu8z42XbXTOuS9+8YvunHPOCT6f4jOoIq+A9u/fr66uLrW2tpaX1dTUqLW1VZ2dnQlnlp2dO3eqp6dn2DYXCgUtWbKkqre5r69PkjRt2jRJUldXl4aGhoZt54IFCzRnzpyq3c6DBw9q48aNGhwcVEtLy7jbxra2Nn384x8ftj3S+DqWO3bs0KxZs/Se97xHl112mXbt2iVpfG3jD37wA51xxhn6xCc+oeOPP16nnXaa7r777vLzKT6DKjIA/fa3v9XBgwfV1NQ0bHlTU5N6enoSzSpbb2/XeNrmUqmk1atXa+nSpTrllFMkvbWd9fX1amxsHLZuNW7nCy+8oClTpiifz+vKK6/U5s2bdfLJJ4+rbdy4caOeffZZtbe3j3huvGznkiVLdO+99+qRRx7Rhg0btHPnTn3oQx/SwMDAuNlGSfrlL3+pDRs2aP78+Xr00Ud11VVX6XOf+5zuu+8+SWk+gyquHQPGj7a2Nr344ovDvk8fT0488UQ9//zz6uvr07/9279p5cqV6ujoSD2taLq7u3XNNdfoscce08SJE1NPJzMXXHBB+b8XLlyoJUuWaO7cufr+97+vSZMmJZxZXKVSSWeccYZuvPFGSdJpp52mF198UXfeeadWrlyZZE4VeQV03HHHacKECSMyTXp7e9Xc3JxoVtl6e7vGyzavWrVKP/zhD/WjH/2o3N9Jems79+/fr7179w5bvxq3s76+Xu9973u1ePFitbe3a9GiRfrGN74xbraxq6tLe/bs0emnn67a2lrV1taqo6NDt99+u2pra9XU1DQutvOdGhsb9b73vU+vvvrquDmWkjRz5kydfPLJw5addNJJ5a8bU3wGVWQAqq+v1+LFi7Vly5byslKppC1btqilpSXhzLIzb948NTc3D9vm/v5+bd26taq22TmnVatWafPmzXr88cc1b968Yc8vXrxYdXV1w7Zz+/bt2rVrV1Vtp0+pVFKxWBw323j++efrhRde0PPPP19+nHHGGbrsssvK/z0etvOdXn/9df3iF7/QzJkzx82xlKSlS5eO+EnEz3/+c82dO1dSos+gTFIbIti4caPL5/Pu3nvvdS+//LK74oorXGNjo+vp6Uk9tcM2MDDgnnvuOffcc885Se7rX/+6e+6559yvfvUr55xzN910k2tsbHQPPvig+9nPfuaWL1/u5s2b5958883EMx+9q666yhUKBffEE0+41157rfx44403yutceeWVbs6cOe7xxx9327Ztcy0tLa6lpSXhrO2uvfZa19HR4Xbu3Ol+9rOfuWuvvdblcjn3H//xH8658bGNPn+YBefc+NjOz3/+8+6JJ55wO3fudD/5yU9ca2urO+6449yePXucc+NjG51z7umnn3a1tbXu7//+792OHTvc9773PXfMMce4f/7nfy6vc6Q/gyo2ADnn3De/+U03Z84cV19f78466yz31FNPpZ7SmPzoRz9ykkY8Vq5c6Zx7Kw3yuuuuc01NTS6fz7vzzz/fbd++Pe2kjXzbJ8ndc8895XXefPNN99d//dfu2GOPdcccc4z7sz/7M/faa6+lm/Rh+Ku/+is3d+5cV19f72bMmOHOP//8cvBxbnxso887A9B42M5LL73UzZw509XX17t3vetd7tJLL3Wvvvpq+fnxsI1ve+ihh9wpp5zi8vm8W7BggbvrrruGPX+kP4PoBwQASKIi7wEBAMY/AhAAIAkCEAAgCQIQACAJAhAAIAkCEAAgCQIQACAJAhAAIAkCEAAgCQIQACAJAhAAIIn/Dyg+jU7Qt7OKAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "l=np.random.randint(0,len(centers))\n", - "data_loader.plot_image_with_centers(l)\n", - "plt.imshow(images[l])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# Normalize the data and split it into training and validation sets\n", - "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", - "\n", - "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", - "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train Images: (800000, 64, 64), Train Midpoints: (800000, 1, 5, 2)\n", - "Validation Images: (200000, 64, 64), Validation Midpoints: (200000, 1, 5, 2)\n" - ] - } - ], - "source": [ - "\n", - "batch_size = 2000\n", - "train_dataset = train_dataset.shuffle(buffer_size=10000, reshuffle_each_iteration=True).batch(batch_size)\n", - "val_dataset = val_dataset.shuffle(buffer_size=10000).batch(batch_size)\n", - "\n", - "# Check the shape of the datasets\n", - "print(f'Train Images: {train_images.shape}, Train Midpoints: {train_midpoints.shape}')\n", - "print(f'Validation Images: {val_images.shape}, Validation Midpoints: {val_midpoints.shape}')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_transposed_images_with_midpoints(train_dataset, image_indices=[0, 1, 2, 3])" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "\n", - "# Set up learning rate scheduler\n", - "lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(\n", - " monitor='val_loss', factor=0.9, patience=10, verbose=1, mode='min', min_lr=7e-8\n", - ")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# import tensorflow as tf\n", - "##### used this initially \n", - "# class DynamicHuberLoss(tf.keras.losses.Loss):\n", - "# def __init__(self, initial_delta, final_delta, total_epochs, **kwargs):\n", - "# super().__init__(**kwargs)\n", - "# self.initial_delta = initial_delta\n", - "# self.final_delta = final_delta\n", - "# self.total_epochs = total_epochs\n", - "# self.current_epoch = 0\n", - "\n", - "# def call(self, y_true, y_pred):\n", - "# # Compute current delta\n", - "# delta = self.initial_delta - ((self.initial_delta - self.final_delta) * (self.current_epoch / self.total_epochs))\n", - "# # Compute Huber loss with current delta\n", - "# return tf.keras.losses.huber(y_true, y_pred, delta=delta)\n", - "\n", - "# def update_epoch(self, epoch):\n", - "# self.current_epoch = epoch\n", - "\n", - "class DynamicHuberLoss(tf.keras.losses.Loss):\n", - " def __init__(self, initial_delta=1.0, final_delta=0.5, total_epochs=450, **kwargs):\n", - " super().__init__(**kwargs)\n", - " self.initial_delta = initial_delta\n", - " self.final_delta = final_delta\n", - " self.total_epochs = total_epochs\n", - " self.current_epoch = 0\n", - "\n", - " def call(self, y_true, y_pred):\n", - " # Dynamically adjust delta based on the current epoch\n", - " delta = self.initial_delta - ((self.initial_delta - self.final_delta) * (self.current_epoch / self.total_epochs))\n", - " error = y_true - y_pred\n", - " abs_error = tf.abs(error)\n", - " quadratic = tf.minimum(abs_error, delta)\n", - " linear = abs_error - quadratic\n", - " loss = 0.5 * quadratic**2 + delta * linear\n", - " return tf.reduce_mean(loss)\n", - "\n", - " def update_epoch(self, epoch):\n", - " self.current_epoch = epoch" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# Instantiate the dynamic Huber loss\n", - "dynamic_huber_loss = DynamicHuberLoss(initial_delta=1.0, final_delta=0.5, total_epochs=450)\n", - "\n", - "\n", - "\n", - "# Create a custom callback to update the epoch\n", - "class UpdateEpochCallback(tf.keras.callbacks.Callback):\n", - " def __init__(self, loss_fn):\n", - " super().__init__()\n", - " self.loss_fn = loss_fn\n", - " self.current_epoch = 0\n", - "\n", - " def on_epoch_begin(self, epoch, logs=None):\n", - " self.loss_fn.update_epoch(epoch)\n", - "\n", - "# Instantiate the callback\n", - "update_epoch_callback = UpdateEpochCallback(dynamic_huber_loss)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
Model: \"functional\"\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1mModel: \"functional\"\u001b[0m\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃ Layer (type)        ┃ Output Shape      ┃    Param # ┃ Connected to      ┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n",
-       "│ input_layer         │ (None, 64, 64, 1) │          0 │ -                 │\n",
-       "│ (InputLayer)        │                   │            │                   │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ conv2d (Conv2D)     │ (None, 64, 64,    │      1,184 │ input_layer[0][0] │\n",
-       "│                     │ 32)               │            │                   │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ conv2d_1 (Conv2D)   │ (None, 64, 64,    │      2,080 │ input_layer[0][0] │\n",
-       "│                     │ 32)               │            │                   │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ conv2d_2 (Conv2D)   │ (None, 64, 64,    │     23,168 │ input_layer[0][0] │\n",
-       "│                     │ 64)               │            │                   │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ concatenate         │ (None, 64, 64,    │          0 │ conv2d[0][0],     │\n",
-       "│ (Concatenate)       │ 128)              │            │ conv2d_1[0][0],   │\n",
-       "│                     │                   │            │ conv2d_2[0][0]    │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ flatten (Flatten)   │ (None, 524288)    │          0 │ concatenate[0][0] │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ dense (Dense)       │ (None, 64)        │ 33,554,496 │ flatten[0][0]     │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ dense_1 (Dense)     │ (None, 32)        │      2,080 │ dense[0][0]       │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ dense_2 (Dense)     │ (None, 16)        │        528 │ dense_1[0][0]     │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ x_midpoints (Dense) │ (None, 10)        │        170 │ dense_2[0][0]     │\n",
-       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
-       "│ x_midpoints_reshape │ (None, 1, 5, 2)   │          0 │ x_midpoints[0][0] │\n",
-       "│ (Reshape)           │                   │            │                   │\n",
-       "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n",
-       "
\n" - ], - "text/plain": [ - "┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n", - "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n", - "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n", - "│ input_layer │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n", - "│ (\u001b[38;5;33mInputLayer\u001b[0m) │ │ │ │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, │ \u001b[38;5;34m1,184\u001b[0m │ input_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "│ │ \u001b[38;5;34m32\u001b[0m) │ │ │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, │ \u001b[38;5;34m2,080\u001b[0m │ input_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "│ │ \u001b[38;5;34m32\u001b[0m) │ │ │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, │ \u001b[38;5;34m23,168\u001b[0m │ input_layer[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "│ │ \u001b[38;5;34m64\u001b[0m) │ │ │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ concatenate │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, │ \u001b[38;5;34m0\u001b[0m │ conv2d[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ (\u001b[38;5;33mConcatenate\u001b[0m) │ \u001b[38;5;34m128\u001b[0m) │ │ conv2d_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n", - "│ │ │ │ conv2d_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m524288\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ concatenate[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m33,554,496\u001b[0m │ flatten[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m2,080\u001b[0m │ dense[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m528\u001b[0m │ dense_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ x_midpoints (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m170\u001b[0m │ dense_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n", - "│ x_midpoints_reshape │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m5\u001b[0m, \u001b[38;5;34m2\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ x_midpoints[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n", - "│ (\u001b[38;5;33mReshape\u001b[0m) │ │ │ │\n", - "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
 Total params: 33,583,706 (128.11 MB)\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m33,583,706\u001b[0m (128.11 MB)\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
 Trainable params: 33,583,706 (128.11 MB)\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m33,583,706\u001b[0m (128.11 MB)\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
 Non-trainable params: 0 (0.00 B)\n",
-       "
\n" - ], - "text/plain": [ - "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Initialize the ModelBuilder within the strategy scope\n", - "with strategy.scope():\n", - " # Instantiate the model builder\n", - " model_builder = ModelBuilder()\n", - "\n", - " # Build the model\n", - " model_builder.build_model()\n", - "\n", - " # Display the model architecture\n", - " model_builder.model.summary()\n", - "\n", - " # Compile the model\n", - " model_builder.compile_model(loss_function=tf.keras.losses.MeanSquaredError())\n", - " # If using a custom loss function, replace the above line with:\n", - " # model_builder.compile_model(loss_function=custom_loss(exponent=2))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:49:31.163390: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", - "2024-09-19 21:49:31.174161: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", - "2024-09-19 21:49:31.203289: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n", - "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "W0000 00:00:1726782571.257670 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.261441 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.261704 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.309460 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.309472 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.309566 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.317437 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.339326 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.339337 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.347874 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.348579 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.350604 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.350711 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.351124 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.370039 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.377026 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.377283 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.381099 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.381451 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.382652 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.382755 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.383054 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.385594 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.386072 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.387366 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.387831 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.391342 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.391837 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.406680 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.406704 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.411220 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.412439 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.412461 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.429428 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.430793 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.431882 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.432449 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.434715 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.436049 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.436858 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.437811 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.438519 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.444609 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.445403 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.447036 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.451213 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.455862 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.457190 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.463412 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.470766 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.472292 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.483024 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.483137 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.483691 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.492328 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.505711 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.510730 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.511980 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.514368 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.519369 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.527163 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.538496 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.538979 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.554933 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.565321 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.575874 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.584233 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.594002 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.598829 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.621520 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.625212 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.659010 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.667410 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.685746 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.686378 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.687758 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.689397 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.691678 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.693021 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.694753 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.702349 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.706384 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.710583 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.713153 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.716567 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.722806 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.730153 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.739101 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.761702 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.768517 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.769886 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.771515 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.772750 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.773746 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.773980 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.775222 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.775322 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.776961 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.777550 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.778546 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.784536 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.786295 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.786376 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.790409 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.790579 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.791950 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.794785 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.796289 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.796507 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.800220 742193 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.800376 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.802704 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.810014 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.814424 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.819020 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.819105 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782571.841440 742194 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.168071 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.168148 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.170340 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.171282 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.173085 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.174195 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.175957 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.176916 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.180023 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.180964 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.183653 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.183897 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.187207 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.187297 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.190209 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.190299 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.194225 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.194396 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.196443 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.196537 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.199797 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.199881 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.206604 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.206706 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.209703 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.209862 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.218549 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.218953 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.237351 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.237514 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.239733 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.240069 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.242394 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.242857 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.244799 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.245224 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.247281 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.247709 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.250075 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.250492 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.252712 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.253073 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.255367 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.255737 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.258808 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.259204 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.259982 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.260402 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.262875 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.263248 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.269461 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.269782 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.272440 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.272795 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.279907 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.280015 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.303581 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.303652 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.312908 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.313074 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.322209 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.322386 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.332421 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.332678 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.343371 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.343700 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.354930 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.355351 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.366505 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.366937 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.377099 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.377602 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.397590 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.397698 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.400600 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.406989 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.408474 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.408643 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.409740 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.412369 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.416432 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.419344 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.421717 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.421916 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.422143 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.424989 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.428967 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.430420 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.433408 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.439140 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.439212 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.440027 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.443101 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.450791 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.452160 742178 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.452365 742181 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.468334 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.471263 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.473857 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.476247 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.478727 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.481500 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.484133 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.486791 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.490257 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.491438 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.494294 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.500833 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.503840 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.511087 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.534721 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.544127 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.553433 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.563712 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.574723 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.586369 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.597979 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.608668 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.625453 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.636392 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.649738 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.666621 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782572.679795 742192 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0406" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:49:57.066905: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "2024-09-19 21:49:57.066970: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "2024-09-19 21:49:57.067121: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "\t [[RemoteCall]]\n", - "W0000 00:00:1726782599.759878 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.764279 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.765283 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.766429 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.767812 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.767945 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.768044 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.769033 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.769611 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.770250 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.770698 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.771594 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.772658 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.773226 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.774128 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.775578 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.775797 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.776622 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.778331 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.779121 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.779640 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.781314 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.781913 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.783266 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.784931 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.785542 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.786148 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.787834 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.789337 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.789854 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.791541 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.793745 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.793933 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.795412 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.797759 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.798427 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.800090 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.801433 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.802303 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.803946 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.805660 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.806001 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.807640 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.810246 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.811876 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.813717 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.818305 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.819894 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.821742 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.826345 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.827208 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.828031 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.828040 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.829113 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.831046 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.831848 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.832576 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.833517 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.834250 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.835347 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.836019 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.836548 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.837321 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.838524 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.842323 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.843523 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.853823 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.855138 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.856464 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.859990 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.859989 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.860944 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.861318 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.862269 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.862643 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.863419 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.863612 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.866189 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.867251 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.867330 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.869631 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.869946 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.870786 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.873391 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.874542 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.876040 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.877204 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.877967 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.884044 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.885244 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.885997 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.890527 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.892050 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.893274 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.896036 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.896602 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.897842 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.902036 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.902209 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.903390 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.907810 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.908001 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.909419 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.914035 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.915294 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.915371 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.921208 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.921488 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.922837 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.927010 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.927435 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.928786 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.933202 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.933379 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.934647 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.939580 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.940502 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.940852 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.941391 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.942562 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.946966 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.947859 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.948246 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.949205 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.949316 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.950542 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.951006 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.953201 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.957706 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.959047 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.959908 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.960956 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.961253 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.967735 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.969079 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.987203 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.993775 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782599.995032 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.002625 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.009168 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.010450 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.013633 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.020272 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.021564 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.024683 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.031423 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.032728 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.033859 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.040503 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.043899 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.047223 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.053692 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.057147 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.064727 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.071480 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.074620 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.081971 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.088901 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.091553 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.097656 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.104729 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.107186 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.117539 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.125042 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.127070 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.145225 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.153149 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.154803 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.173582 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.181940 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.183460 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.204740 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.213114 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.214862 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.230385 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.238839 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.240780 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.277944 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.286555 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.288829 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.340390 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.344551 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.349758 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.351550 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.351760 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.354016 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.355975 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.361105 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.362997 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.377886 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.387980 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.389131 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.389460 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.399468 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.400753 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.427167 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.437795 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.438863 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.542007 742182 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.552476 742189 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1726782600.555064 742165 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 78ms/step - loss: 0.0406 - val_loss: 0.0488 - learning_rate: 0.0100\n", - "Epoch 2/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:50:03.941005: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0263" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:50:35.402883: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "\t [[RemoteCall]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 76ms/step - loss: 0.0264 - val_loss: 0.0489 - learning_rate: 0.0100\n", - "Epoch 3/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 75ms/step - loss: 0.0263 - val_loss: 0.0489 - learning_rate: 0.0100\n", - "Epoch 4/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:51:17.655331: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 76ms/step - loss: 0.0255 - val_loss: 0.0491 - learning_rate: 0.0100\n", - "Epoch 5/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 76ms/step - loss: 0.0253 - val_loss: 0.0489 - learning_rate: 0.0100\n", - "Epoch 6/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0262" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:53:01.974756: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "\t [[RemoteCall]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0263 - val_loss: 0.0491 - learning_rate: 0.0100\n", - "Epoch 7/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 75ms/step - loss: 0.0255 - val_loss: 0.0487 - learning_rate: 0.0100\n", - "Epoch 8/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 76ms/step - loss: 0.0254 - val_loss: 0.0493 - learning_rate: 0.0100\n", - "Epoch 9/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0250 - val_loss: 0.0489 - learning_rate: 0.0100\n", - "Epoch 10/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0250 - val_loss: 0.0487 - learning_rate: 0.0100\n", - "Epoch 11/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0248\n", - "Epoch 11: ReduceLROnPlateau reducing learning rate to 0.008999999798834325.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0249 - val_loss: 0.0491 - learning_rate: 0.0100\n", - "Epoch 12/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 21:55:54.392304: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 85ms/step - loss: 0.0252 - val_loss: 0.0490 - learning_rate: 0.0090\n", - "Epoch 13/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 77ms/step - loss: 0.0248 - val_loss: 0.0492 - learning_rate: 0.0090\n", - "Epoch 14/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 72ms/step - loss: 0.0246 - val_loss: 0.0489 - learning_rate: 0.0090\n", - "Epoch 15/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 77ms/step - loss: 0.0246 - val_loss: 0.0488 - learning_rate: 0.0090\n", - "Epoch 16/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 72ms/step - loss: 0.0245 - val_loss: 0.0490 - learning_rate: 0.0090\n", - "Epoch 17/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0244 - val_loss: 0.0489 - learning_rate: 0.0090\n", - "Epoch 18/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 77ms/step - loss: 0.0244 - val_loss: 0.0489 - learning_rate: 0.0090\n", - "Epoch 19/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0243 - val_loss: 0.0489 - learning_rate: 0.0090\n", - "Epoch 20/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0242 - val_loss: 0.0488 - learning_rate: 0.0090\n", - "Epoch 21/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0242\n", - "Epoch 21: ReduceLROnPlateau reducing learning rate to 0.008099999651312828.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0243 - val_loss: 0.0490 - learning_rate: 0.0090\n", - "Epoch 22/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0245" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:02:15.955678: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "\t [[RemoteCall]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0246 - val_loss: 0.0489 - learning_rate: 0.0081\n", - "Epoch 23/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0243 - val_loss: 0.0492 - learning_rate: 0.0081\n", - "Epoch 24/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 76ms/step - loss: 0.0242 - val_loss: 0.0489 - learning_rate: 0.0081\n", - "Epoch 25/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0241 - val_loss: 0.0491 - learning_rate: 0.0081\n", - "Epoch 26/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0244 - val_loss: 0.0488 - learning_rate: 0.0081\n", - "Epoch 27/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0241 - val_loss: 0.0490 - learning_rate: 0.0081\n", - "Epoch 28/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0241 - val_loss: 0.0488 - learning_rate: 0.0081\n", - "Epoch 29/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0240 - val_loss: 0.0490 - learning_rate: 0.0081\n", - "Epoch 30/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0241 - val_loss: 0.0485 - learning_rate: 0.0081\n", - "Epoch 31/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 71ms/step - loss: 0.0242 - val_loss: 0.0489 - learning_rate: 0.0081\n", - "Epoch 32/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0240 - val_loss: 0.0488 - learning_rate: 0.0081\n", - "Epoch 33/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0240 - val_loss: 0.0488 - learning_rate: 0.0081\n", - "Epoch 34/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0242 - val_loss: 0.0488 - learning_rate: 0.0081\n", - "Epoch 35/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0240 - val_loss: 0.0489 - learning_rate: 0.0081\n", - "Epoch 36/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0240 - val_loss: 0.0486 - learning_rate: 0.0081\n", - "Epoch 37/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0240 - val_loss: 0.0489 - learning_rate: 0.0081\n", - "Epoch 38/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0240 - val_loss: 0.0489 - learning_rate: 0.0081\n", - "Epoch 39/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0239 - val_loss: 0.0491 - learning_rate: 0.0081\n", - "Epoch 40/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - loss: 0.0240\n", - "Epoch 40: ReduceLROnPlateau reducing learning rate to 0.007289999350905419.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 72ms/step - loss: 0.0240 - val_loss: 0.0490 - learning_rate: 0.0081\n", - "Epoch 41/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0240 - val_loss: 0.0489 - learning_rate: 0.0073\n", - "Epoch 42/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0241 - val_loss: 0.0489 - learning_rate: 0.0073\n", - "Epoch 43/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0239 - val_loss: 0.0489 - learning_rate: 0.0073\n", - "Epoch 44/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:13:48.907959: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0240 - val_loss: 0.0490 - learning_rate: 0.0073\n", - "Epoch 45/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0239 - val_loss: 0.0489 - learning_rate: 0.0073\n", - "Epoch 46/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0238 - val_loss: 0.0491 - learning_rate: 0.0073\n", - "Epoch 47/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0239 - val_loss: 0.0491 - learning_rate: 0.0073\n", - "Epoch 48/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 72ms/step - loss: 0.0240 - val_loss: 0.0490 - learning_rate: 0.0073\n", - "Epoch 49/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0238 - val_loss: 0.0489 - learning_rate: 0.0073\n", - "Epoch 50/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - loss: 0.0238\n", - "Epoch 50: ReduceLROnPlateau reducing learning rate to 0.006560999248176813.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0239 - val_loss: 0.0490 - learning_rate: 0.0073\n", - "Epoch 51/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0239 - val_loss: 0.0491 - learning_rate: 0.0066\n", - "Epoch 52/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0239 - val_loss: 0.0491 - learning_rate: 0.0066\n", - "Epoch 53/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0238 - val_loss: 0.0489 - learning_rate: 0.0066\n", - "Epoch 54/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0491 - learning_rate: 0.0066\n", - "Epoch 55/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0238 - val_loss: 0.0490 - learning_rate: 0.0066\n", - "Epoch 56/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0238 - val_loss: 0.0489 - learning_rate: 0.0066\n", - "Epoch 57/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 73ms/step - loss: 0.0240 - val_loss: 0.0492 - learning_rate: 0.0066\n", - "Epoch 58/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0239 - val_loss: 0.0490 - learning_rate: 0.0066\n", - "Epoch 59/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0238 - val_loss: 0.0488 - learning_rate: 0.0066\n", - "Epoch 60/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - loss: 0.0238\n", - "Epoch 60: ReduceLROnPlateau reducing learning rate to 0.005904899490997195.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0238 - val_loss: 0.0489 - learning_rate: 0.0066\n", - "Epoch 61/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0238 - val_loss: 0.0493 - learning_rate: 0.0059\n", - "Epoch 62/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0488 - learning_rate: 0.0059\n", - "Epoch 63/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0488 - learning_rate: 0.0059\n", - "Epoch 64/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 73ms/step - loss: 0.0244 - val_loss: 0.0487 - learning_rate: 0.0059\n", - "Epoch 65/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0241 - val_loss: 0.0491 - learning_rate: 0.0059\n", - "Epoch 66/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0488 - learning_rate: 0.0059\n", - "Epoch 67/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0238 - val_loss: 0.0487 - learning_rate: 0.0059\n", - "Epoch 68/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0239 - val_loss: 0.0487 - learning_rate: 0.0059\n", - "Epoch 69/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0493 - learning_rate: 0.0059\n", - "Epoch 70/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0236\n", - "Epoch 70: ReduceLROnPlateau reducing learning rate to 0.00531440949998796.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0489 - learning_rate: 0.0059\n", - "Epoch 71/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0238 - val_loss: 0.0492 - learning_rate: 0.0053\n", - "Epoch 72/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0490 - learning_rate: 0.0053\n", - "Epoch 73/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0238 - val_loss: 0.0489 - learning_rate: 0.0053\n", - "Epoch 74/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0490 - learning_rate: 0.0053\n", - "Epoch 75/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0490 - learning_rate: 0.0053\n", - "Epoch 76/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0489 - learning_rate: 0.0053\n", - "Epoch 77/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0489 - learning_rate: 0.0053\n", - "Epoch 78/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0237 - val_loss: 0.0488 - learning_rate: 0.0053\n", - "Epoch 79/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0492 - learning_rate: 0.0053\n", - "Epoch 80/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0237\n", - "Epoch 80: ReduceLROnPlateau reducing learning rate to 0.004782968759536744.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 77ms/step - loss: 0.0238 - val_loss: 0.0490 - learning_rate: 0.0053\n", - "Epoch 81/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0236 - val_loss: 0.0490 - learning_rate: 0.0048\n", - "Epoch 82/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0237 - val_loss: 0.0484 - learning_rate: 0.0048\n", - "Epoch 83/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0487 - learning_rate: 0.0048\n", - "Epoch 84/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0491 - learning_rate: 0.0048\n", - "Epoch 85/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0238 - val_loss: 0.0487 - learning_rate: 0.0048\n", - "Epoch 86/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0236" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 22:37:25.181609: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0489 - learning_rate: 0.0048\n", - "Epoch 87/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0489 - learning_rate: 0.0048\n", - "Epoch 88/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0491 - learning_rate: 0.0048\n", - "Epoch 89/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 76ms/step - loss: 0.0236 - val_loss: 0.0491 - learning_rate: 0.0048\n", - "Epoch 90/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0492 - learning_rate: 0.0048\n", - "Epoch 91/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 76ms/step - loss: 0.0236 - val_loss: 0.0490 - learning_rate: 0.0048\n", - "Epoch 92/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - loss: 0.0236\n", - "Epoch 92: ReduceLROnPlateau reducing learning rate to 0.0043046717997640375.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0488 - learning_rate: 0.0048\n", - "Epoch 93/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0488 - learning_rate: 0.0043\n", - "Epoch 94/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0492 - learning_rate: 0.0043\n", - "Epoch 95/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0236 - val_loss: 0.0488 - learning_rate: 0.0043\n", - "Epoch 96/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0489 - learning_rate: 0.0043\n", - "Epoch 97/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0236 - val_loss: 0.0488 - learning_rate: 0.0043\n", - "Epoch 98/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0490 - learning_rate: 0.0043\n", - "Epoch 99/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0237 - val_loss: 0.0488 - learning_rate: 0.0043\n", - "Epoch 100/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0488 - learning_rate: 0.0043\n", - "Epoch 101/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0236 - val_loss: 0.0490 - learning_rate: 0.0043\n", - "Epoch 102/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0235\n", - "Epoch 102: ReduceLROnPlateau reducing learning rate to 0.0038742044940590858.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0490 - learning_rate: 0.0043\n", - "Epoch 103/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0488 - learning_rate: 0.0039\n", - "Epoch 104/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0495 - learning_rate: 0.0039\n", - "Epoch 105/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 73ms/step - loss: 0.0235 - val_loss: 0.0488 - learning_rate: 0.0039\n", - "Epoch 106/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0486 - learning_rate: 0.0039\n", - "Epoch 107/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 74ms/step - loss: 0.0236 - val_loss: 0.0486 - learning_rate: 0.0039\n", - "Epoch 108/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0491 - learning_rate: 0.0039\n", - "Epoch 109/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 76ms/step - loss: 0.0236 - val_loss: 0.0489 - learning_rate: 0.0039\n", - "Epoch 110/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0488 - learning_rate: 0.0039\n", - "Epoch 111/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0237 - val_loss: 0.0492 - learning_rate: 0.0039\n", - "Epoch 112/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0236\n", - "Epoch 112: ReduceLROnPlateau reducing learning rate to 0.003486784128472209.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0492 - learning_rate: 0.0039\n", - "Epoch 113/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0488 - learning_rate: 0.0035\n", - "Epoch 114/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0486 - learning_rate: 0.0035\n", - "Epoch 115/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0035\n", - "Epoch 116/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 72ms/step - loss: 0.0236 - val_loss: 0.0491 - learning_rate: 0.0035\n", - "Epoch 117/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0236 - val_loss: 0.0491 - learning_rate: 0.0035\n", - "Epoch 118/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0035\n", - "Epoch 119/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0491 - learning_rate: 0.0035\n", - "Epoch 120/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0035\n", - "Epoch 121/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0491 - learning_rate: 0.0035\n", - "Epoch 122/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0235\n", - "Epoch 122: ReduceLROnPlateau reducing learning rate to 0.003138105757534504.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0487 - learning_rate: 0.0035\n", - "Epoch 123/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0236 - val_loss: 0.0490 - learning_rate: 0.0031\n", - "Epoch 124/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0491 - learning_rate: 0.0031\n", - "Epoch 125/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0487 - learning_rate: 0.0031\n", - "Epoch 126/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0235 - val_loss: 0.0491 - learning_rate: 0.0031\n", - "Epoch 127/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0031\n", - "Epoch 128/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0490 - learning_rate: 0.0031\n", - "Epoch 129/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0235 - val_loss: 0.0488 - learning_rate: 0.0031\n", - "Epoch 130/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0490 - learning_rate: 0.0031\n", - "Epoch 131/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 74ms/step - loss: 0.0235 - val_loss: 0.0490 - learning_rate: 0.0031\n", - "Epoch 132/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0234\n", - "Epoch 132: ReduceLROnPlateau reducing learning rate to 0.0028242952656000854.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0488 - learning_rate: 0.0031\n", - "Epoch 133/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0235 - val_loss: 0.0488 - learning_rate: 0.0028\n", - "Epoch 134/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0235 - val_loss: 0.0488 - learning_rate: 0.0028\n", - "Epoch 135/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0487 - learning_rate: 0.0028\n", - "Epoch 136/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0028\n", - "Epoch 137/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0028\n", - "Epoch 138/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0235 - val_loss: 0.0492 - learning_rate: 0.0028\n", - "Epoch 139/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0028\n", - "Epoch 140/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 75ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0028\n", - "Epoch 141/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0235 - val_loss: 0.0490 - learning_rate: 0.0028\n", - "Epoch 142/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0234\n", - "Epoch 142: ReduceLROnPlateau reducing learning rate to 0.0025418657809495927.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 74ms/step - loss: 0.0234 - val_loss: 0.0487 - learning_rate: 0.0028\n", - "Epoch 143/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0236 - val_loss: 0.0489 - learning_rate: 0.0025\n", - "Epoch 144/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0025\n", - "Epoch 145/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0025\n", - "Epoch 146/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0025\n", - "Epoch 147/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0025\n", - "Epoch 148/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0025\n", - "Epoch 149/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0025\n", - "Epoch 150/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0025\n", - "Epoch 151/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0489 - learning_rate: 0.0025\n", - "Epoch 152/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0234\n", - "Epoch 152: ReduceLROnPlateau reducing learning rate to 0.0022876791190356016.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0025\n", - "Epoch 153/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0487 - learning_rate: 0.0023\n", - "Epoch 154/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0023\n", - "Epoch 155/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0486 - learning_rate: 0.0023\n", - "Epoch 156/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0023\n", - "Epoch 157/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0234 - val_loss: 0.0491 - learning_rate: 0.0023\n", - "Epoch 158/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 0.0023\n", - "Epoch 159/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 72ms/step - loss: 0.0234 - val_loss: 0.0487 - learning_rate: 0.0023\n", - "Epoch 160/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0023\n", - "Epoch 161/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0023\n", - "Epoch 162/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0234\n", - "Epoch 162: ReduceLROnPlateau reducing learning rate to 0.0020589112071320416.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0023\n", - "Epoch 163/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0021\n", - "Epoch 164/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 75ms/step - loss: 0.0234 - val_loss: 0.0491 - learning_rate: 0.0021\n", - "Epoch 165/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0021\n", - "Epoch 166/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0021\n", - "Epoch 167/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0021\n", - "Epoch 168/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0235 - val_loss: 0.0489 - learning_rate: 0.0021\n", - "Epoch 169/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0492 - learning_rate: 0.0021\n", - "Epoch 170/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 74ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0021\n", - "Epoch 171/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0021\n", - "Epoch 172/800\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-19 23:23:48.028142: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "\t [[RemoteCall]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0233\n", - "Epoch 172: ReduceLROnPlateau reducing learning rate to 0.0018530200235545636.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 72ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0021\n", - "Epoch 173/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 0.0019\n", - "Epoch 174/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0489 - learning_rate: 0.0019\n", - "Epoch 175/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0487 - learning_rate: 0.0019\n", - "Epoch 176/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0019\n", - "Epoch 177/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 0.0019\n", - "Epoch 178/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0493 - learning_rate: 0.0019\n", - "Epoch 179/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0019\n", - "Epoch 180/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0234 - val_loss: 0.0489 - learning_rate: 0.0019\n", - "Epoch 181/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0019\n", - "Epoch 182/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0233\n", - "Epoch 182: ReduceLROnPlateau reducing learning rate to 0.0016677180421538651.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0494 - learning_rate: 0.0019\n", - "Epoch 183/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 0.0017\n", - "Epoch 184/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 0.0017\n", - "Epoch 185/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 0.0017\n", - "Epoch 186/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0487 - learning_rate: 0.0017\n", - "Epoch 187/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0017\n", - "Epoch 188/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0234 - val_loss: 0.0491 - learning_rate: 0.0017\n", - "Epoch 189/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0017\n", - "Epoch 190/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0234 - val_loss: 0.0489 - learning_rate: 0.0017\n", - "Epoch 191/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0487 - learning_rate: 0.0017\n", - "Epoch 192/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0234\n", - "Epoch 192: ReduceLROnPlateau reducing learning rate to 0.0015009462484158575.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0492 - learning_rate: 0.0017\n", - "Epoch 193/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 74ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0015\n", - "Epoch 194/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0015\n", - "Epoch 195/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 0.0015\n", - "Epoch 196/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 0.0015\n", - "Epoch 197/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0492 - learning_rate: 0.0015\n", - "Epoch 198/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0015\n", - "Epoch 199/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0015\n", - "Epoch 200/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0491 - learning_rate: 0.0015\n", - "Epoch 201/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0489 - learning_rate: 0.0015\n", - "Epoch 202/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0233\n", - "Epoch 202: ReduceLROnPlateau reducing learning rate to 0.0013508516130968928.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 0.0015\n", - "Epoch 203/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 0.0014\n", - "Epoch 204/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0014\n", - "Epoch 205/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0491 - learning_rate: 0.0014\n", - "Epoch 206/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0494 - learning_rate: 0.0014\n", - "Epoch 207/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0014\n", - "Epoch 208/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 0.0014\n", - "Epoch 209/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 0.0014\n", - "Epoch 210/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 0.0014\n", - "Epoch 211/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0014\n", - "Epoch 212/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0232\n", - "Epoch 212: ReduceLROnPlateau reducing learning rate to 0.0012157664517872036.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 0.0014\n", - "Epoch 213/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0486 - learning_rate: 0.0012\n", - "Epoch 214/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0012\n", - "Epoch 215/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0234 - val_loss: 0.0485 - learning_rate: 0.0012\n", - "Epoch 216/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 0.0012\n", - "Epoch 217/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0487 - learning_rate: 0.0012\n", - "Epoch 218/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 0.0012\n", - "Epoch 219/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 0.0012\n", - "Epoch 220/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0012\n", - "Epoch 221/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 0.0012\n", - "Epoch 222/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0234\n", - "Epoch 222: ReduceLROnPlateau reducing learning rate to 0.0010941897751763463.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0235 - val_loss: 0.0486 - learning_rate: 0.0012\n", - "Epoch 223/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 0.0011\n", - "Epoch 224/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0493 - learning_rate: 0.0011\n", - "Epoch 225/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0488 - learning_rate: 0.0011\n", - "Epoch 226/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 0.0011\n", - "Epoch 227/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 0.0011\n", - "Epoch 228/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 0.0011\n", - "Epoch 229/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 74ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 0.0011\n", - "Epoch 230/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0487 - learning_rate: 0.0011\n", - "Epoch 231/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0489 - learning_rate: 0.0011\n", - "Epoch 232/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0232\n", - "Epoch 232: ReduceLROnPlateau reducing learning rate to 0.0009847708395682275.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0486 - learning_rate: 0.0011\n", - "Epoch 233/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 9.8477e-04\n", - "Epoch 234/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0492 - learning_rate: 9.8477e-04\n", - "Epoch 235/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 9.8477e-04\n", - "Epoch 236/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 9.8477e-04\n", - "Epoch 237/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0234 - val_loss: 0.0490 - learning_rate: 9.8477e-04\n", - "Epoch 238/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 9.8477e-04\n", - "Epoch 239/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 9.8477e-04\n", - "Epoch 240/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 9.8477e-04\n", - "Epoch 241/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 9.8477e-04\n", - "Epoch 242/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 242: ReduceLROnPlateau reducing learning rate to 0.0008862937451340258.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 9.8477e-04\n", - "Epoch 243/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 8.8629e-04\n", - "Epoch 244/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0492 - learning_rate: 8.8629e-04\n", - "Epoch 245/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 8.8629e-04\n", - "Epoch 246/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 8.8629e-04\n", - "Epoch 247/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 8.8629e-04\n", - "Epoch 248/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 8.8629e-04\n", - "Epoch 249/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 8.8629e-04\n", - "Epoch 250/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0485 - learning_rate: 8.8629e-04\n", - "Epoch 251/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 8.8629e-04\n", - "Epoch 252/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0233\n", - "Epoch 252: ReduceLROnPlateau reducing learning rate to 0.0007976643915753812.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 8.8629e-04\n", - "Epoch 253/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 7.9766e-04\n", - "Epoch 254/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 7.9766e-04\n", - "Epoch 255/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 7.9766e-04\n", - "Epoch 256/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 7.9766e-04\n", - "Epoch 257/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 7.9766e-04\n", - "Epoch 258/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 7.9766e-04\n", - "Epoch 259/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 7.9766e-04\n", - "Epoch 260/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0486 - learning_rate: 7.9766e-04\n", - "Epoch 261/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 7.9766e-04\n", - "Epoch 262/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0232\n", - "Epoch 262: ReduceLROnPlateau reducing learning rate to 0.0007178979576565325.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0492 - learning_rate: 7.9766e-04\n", - "Epoch 263/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 7.1790e-04\n", - "Epoch 264/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 7.1790e-04\n", - "Epoch 265/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 7.1790e-04\n", - "Epoch 266/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0487 - learning_rate: 7.1790e-04\n", - "Epoch 267/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 7.1790e-04\n", - "Epoch 268/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 7.1790e-04\n", - "Epoch 269/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 7.1790e-04\n", - "Epoch 270/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 7.1790e-04\n", - "Epoch 271/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 7.1790e-04\n", - "Epoch 272/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0232\n", - "Epoch 272: ReduceLROnPlateau reducing learning rate to 0.0006461081618908793.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 7.1790e-04\n", - "Epoch 273/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 72ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 6.4611e-04\n", - "Epoch 274/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 6.4611e-04\n", - "Epoch 275/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0487 - learning_rate: 6.4611e-04\n", - "Epoch 276/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 6.4611e-04\n", - "Epoch 277/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 6.4611e-04\n", - "Epoch 278/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 6.4611e-04\n", - "Epoch 279/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 74ms/step - loss: 0.0233 - val_loss: 0.0486 - learning_rate: 6.4611e-04\n", - "Epoch 280/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 6.4611e-04\n", - "Epoch 281/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 6.4611e-04\n", - "Epoch 282/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0232\n", - "Epoch 282: ReduceLROnPlateau reducing learning rate to 0.0005814973614178598.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 72ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 6.4611e-04\n", - "Epoch 283/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 5.8150e-04\n", - "Epoch 284/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 5.8150e-04\n", - "Epoch 285/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 5.8150e-04\n", - "Epoch 286/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 5.8150e-04\n", - "Epoch 287/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 5.8150e-04\n", - "Epoch 288/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 5.8150e-04\n", - "Epoch 289/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0233 - val_loss: 0.0489 - learning_rate: 5.8150e-04\n", - "Epoch 290/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 5.8150e-04\n", - "Epoch 291/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0485 - learning_rate: 5.8150e-04\n", - "Epoch 292/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 292: ReduceLROnPlateau reducing learning rate to 0.0005233476462308317.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 5.8150e-04\n", - "Epoch 293/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 5.2335e-04\n", - "Epoch 294/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 5.2335e-04\n", - "Epoch 295/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 5.2335e-04\n", - "Epoch 296/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0494 - learning_rate: 5.2335e-04\n", - "Epoch 297/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 5.2335e-04\n", - "Epoch 298/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 5.2335e-04\n", - "Epoch 299/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0493 - learning_rate: 5.2335e-04\n", - "Epoch 300/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0233 - val_loss: 0.0487 - learning_rate: 5.2335e-04\n", - "Epoch 301/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 73ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 5.2335e-04\n", - "Epoch 302/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 302: ReduceLROnPlateau reducing learning rate to 0.0004710128763690591.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 5.2335e-04\n", - "Epoch 303/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 4.7101e-04\n", - "Epoch 304/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0485 - learning_rate: 4.7101e-04\n", - "Epoch 305/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 4.7101e-04\n", - "Epoch 306/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 4.7101e-04\n", - "Epoch 307/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 4.7101e-04\n", - "Epoch 308/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 4.7101e-04\n", - "Epoch 309/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 4.7101e-04\n", - "Epoch 310/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 4.7101e-04\n", - "Epoch 311/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0490 - learning_rate: 4.7101e-04\n", - "Epoch 312/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 312: ReduceLROnPlateau reducing learning rate to 0.0004239115834934637.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 4.7101e-04\n", - "Epoch 313/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 72ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 4.2391e-04\n", - "Epoch 314/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 4.2391e-04\n", - "Epoch 315/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 72ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 4.2391e-04\n", - "Epoch 316/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 4.2391e-04\n", - "Epoch 317/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 4.2391e-04\n", - "Epoch 318/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 4.2391e-04\n", - "Epoch 319/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 4.2391e-04\n", - "Epoch 320/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 4.2391e-04\n", - "Epoch 321/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 4.2391e-04\n", - "Epoch 322/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0232\n", - "Epoch 322: ReduceLROnPlateau reducing learning rate to 0.0003815204225247726.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0233 - val_loss: 0.0488 - learning_rate: 4.2391e-04\n", - "Epoch 323/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.8152e-04\n", - "Epoch 324/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 3.8152e-04\n", - "Epoch 325/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 78ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.8152e-04\n", - "Epoch 326/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 3.8152e-04\n", - "Epoch 327/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 3.8152e-04\n", - "Epoch 328/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0493 - learning_rate: 3.8152e-04\n", - "Epoch 329/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 3.8152e-04\n", - "Epoch 330/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 3.8152e-04\n", - "Epoch 331/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.8152e-04\n", - "Epoch 332/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 332: ReduceLROnPlateau reducing learning rate to 0.0003433683828916401.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 3.8152e-04\n", - "Epoch 333/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 3.4337e-04\n", - "Epoch 334/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 3.4337e-04\n", - "Epoch 335/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0493 - learning_rate: 3.4337e-04\n", - "Epoch 336/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 3.4337e-04\n", - "Epoch 337/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 3.4337e-04\n", - "Epoch 338/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 3.4337e-04\n", - "Epoch 339/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 3.4337e-04\n", - "Epoch 340/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 3.4337e-04\n", - "Epoch 341/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 3.4337e-04\n", - "Epoch 342/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 00:53:38.586397: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "\t [[RemoteCall]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Epoch 342: ReduceLROnPlateau reducing learning rate to 0.0003090315498411656.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 3.4337e-04\n", - "Epoch 343/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 3.0903e-04\n", - "Epoch 344/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.0903e-04\n", - "Epoch 345/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 3.0903e-04\n", - "Epoch 346/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 3.0903e-04\n", - "Epoch 347/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 3.0903e-04\n", - "Epoch 348/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.0903e-04\n", - "Epoch 349/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 3.0903e-04\n", - "Epoch 350/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.0903e-04\n", - "Epoch 351/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0493 - learning_rate: 3.0903e-04\n", - "Epoch 352/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 352: ReduceLROnPlateau reducing learning rate to 0.00027812838961835954.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.0903e-04\n", - "Epoch 353/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 2.7813e-04\n", - "Epoch 354/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.7813e-04\n", - "Epoch 355/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 2.7813e-04\n", - "Epoch 356/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.7813e-04\n", - "Epoch 357/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 2.7813e-04\n", - "Epoch 358/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.7813e-04\n", - "Epoch 359/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 2.7813e-04\n", - "Epoch 360/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 2.7813e-04\n", - "Epoch 361/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 2.7813e-04\n", - "Epoch 362/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 362: ReduceLROnPlateau reducing learning rate to 0.00025031555851455777.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 2.7813e-04\n", - "Epoch 363/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 74ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.5032e-04\n", - "Epoch 364/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 2.5032e-04\n", - "Epoch 365/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 2.5032e-04\n", - "Epoch 366/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 2.5032e-04\n", - "Epoch 367/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0233 - val_loss: 0.0491 - learning_rate: 2.5032e-04\n", - "Epoch 368/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 2.5032e-04\n", - "Epoch 369/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.5032e-04\n", - "Epoch 370/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.5032e-04\n", - "Epoch 371/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 2.5032e-04\n", - "Epoch 372/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 372: ReduceLROnPlateau reducing learning rate to 0.00022528400004375725.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.5032e-04\n", - "Epoch 373/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 2.2528e-04\n", - "Epoch 374/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.2528e-04\n", - "Epoch 375/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 2.2528e-04\n", - "Epoch 376/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 2.2528e-04\n", - "Epoch 377/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 2.2528e-04\n", - "Epoch 378/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 2.2528e-04\n", - "Epoch 379/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 2.2528e-04\n", - "Epoch 380/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 2.2528e-04\n", - "Epoch 381/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.2528e-04\n", - "Epoch 382/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 382: ReduceLROnPlateau reducing learning rate to 0.000202755605278071.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 2.2528e-04\n", - "Epoch 383/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 2.0276e-04\n", - "Epoch 384/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 2.0276e-04\n", - "Epoch 385/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 2.0276e-04\n", - "Epoch 386/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.0276e-04\n", - "Epoch 387/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 2.0276e-04\n", - "Epoch 388/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 72ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.0276e-04\n", - "Epoch 389/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 2.0276e-04\n", - "Epoch 390/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.0276e-04\n", - "Epoch 391/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.0276e-04\n", - "Epoch 392/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 392: ReduceLROnPlateau reducing learning rate to 0.00018248004344059154.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 2.0276e-04\n", - "Epoch 393/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.8248e-04\n", - "Epoch 394/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0493 - learning_rate: 1.8248e-04\n", - "Epoch 395/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 1.8248e-04\n", - "Epoch 396/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 1.8248e-04\n", - "Epoch 397/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 1.8248e-04\n", - "Epoch 398/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 1.8248e-04\n", - "Epoch 399/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0486 - learning_rate: 1.8248e-04\n", - "Epoch 400/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.8248e-04\n", - "Epoch 401/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 1.8248e-04\n", - "Epoch 402/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 402: ReduceLROnPlateau reducing learning rate to 0.00016423203778686004.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.8248e-04\n", - "Epoch 403/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 1.6423e-04\n", - "Epoch 404/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 1.6423e-04\n", - "Epoch 405/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 1.6423e-04\n", - "Epoch 406/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 1.6423e-04\n", - "Epoch 407/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0493 - learning_rate: 1.6423e-04\n", - "Epoch 408/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 1.6423e-04\n", - "Epoch 409/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.6423e-04\n", - "Epoch 410/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.6423e-04\n", - "Epoch 411/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.6423e-04\n", - "Epoch 412/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 412: ReduceLROnPlateau reducing learning rate to 0.00014780883793719113.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.6423e-04\n", - "Epoch 413/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.4781e-04\n", - "Epoch 414/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.4781e-04\n", - "Epoch 415/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.4781e-04\n", - "Epoch 416/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.4781e-04\n", - "Epoch 417/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.4781e-04\n", - "Epoch 418/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 1.4781e-04\n", - "Epoch 419/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.4781e-04\n", - "Epoch 420/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.4781e-04\n", - "Epoch 421/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.4781e-04\n", - "Epoch 422/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 422: ReduceLROnPlateau reducing learning rate to 0.00013302795414347202.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.4781e-04\n", - "Epoch 423/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0230 - val_loss: 0.0488 - learning_rate: 1.3303e-04\n", - "Epoch 424/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0486 - learning_rate: 1.3303e-04\n", - "Epoch 425/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 1.3303e-04\n", - "Epoch 426/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.3303e-04\n", - "Epoch 427/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.3303e-04\n", - "Epoch 428/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.3303e-04\n", - "Epoch 429/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.3303e-04\n", - "Epoch 430/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.3303e-04\n", - "Epoch 431/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 1.3303e-04\n", - "Epoch 432/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 432: ReduceLROnPlateau reducing learning rate to 0.00011972515349043534.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.3303e-04\n", - "Epoch 433/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.1973e-04\n", - "Epoch 434/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.1973e-04\n", - "Epoch 435/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 1.1973e-04\n", - "Epoch 436/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.1973e-04\n", - "Epoch 437/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 1.1973e-04\n", - "Epoch 438/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 72ms/step - loss: 0.0230 - val_loss: 0.0492 - learning_rate: 1.1973e-04\n", - "Epoch 439/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 1.1973e-04\n", - "Epoch 440/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0491 - learning_rate: 1.1973e-04\n", - "Epoch 441/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.1973e-04\n", - "Epoch 442/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 442: ReduceLROnPlateau reducing learning rate to 0.00010775263945106417.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 80ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 1.1973e-04\n", - "Epoch 443/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.0775e-04\n", - "Epoch 444/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.0775e-04\n", - "Epoch 445/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.0775e-04\n", - "Epoch 446/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.0775e-04\n", - "Epoch 447/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.0775e-04\n", - "Epoch 448/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.0775e-04\n", - "Epoch 449/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 1.0775e-04\n", - "Epoch 450/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 1.0775e-04\n", - "Epoch 451/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.0775e-04\n", - "Epoch 452/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 452: ReduceLROnPlateau reducing learning rate to 9.697737550595775e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.0775e-04\n", - "Epoch 453/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 9.6977e-05\n", - "Epoch 454/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 9.6977e-05\n", - "Epoch 455/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 9.6977e-05\n", - "Epoch 456/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 9.6977e-05\n", - "Epoch 457/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 9.6977e-05\n", - "Epoch 458/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 9.6977e-05\n", - "Epoch 459/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 9.6977e-05\n", - "Epoch 460/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 9.6977e-05\n", - "Epoch 461/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 9.6977e-05\n", - "Epoch 462/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0230\n", - "Epoch 462: ReduceLROnPlateau reducing learning rate to 8.727963795536197e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0488 - learning_rate: 9.6977e-05\n", - "Epoch 463/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 8.7280e-05\n", - "Epoch 464/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 8.7280e-05\n", - "Epoch 465/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 8.7280e-05\n", - "Epoch 466/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 72ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 8.7280e-05\n", - "Epoch 467/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 8.7280e-05\n", - "Epoch 468/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 8.7280e-05\n", - "Epoch 469/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 8.7280e-05\n", - "Epoch 470/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 8.7280e-05\n", - "Epoch 471/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 8.7280e-05\n", - "Epoch 472/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 472: ReduceLROnPlateau reducing learning rate to 7.85516735049896e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 8.7280e-05\n", - "Epoch 473/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 7.8552e-05\n", - "Epoch 474/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 7.8552e-05\n", - "Epoch 475/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 7.8552e-05\n", - "Epoch 476/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 7.8552e-05\n", - "Epoch 477/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 7.8552e-05\n", - "Epoch 478/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 7.8552e-05\n", - "Epoch 479/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 7.8552e-05\n", - "Epoch 480/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 7.8552e-05\n", - "Epoch 481/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 7.8552e-05\n", - "Epoch 482/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 482: ReduceLROnPlateau reducing learning rate to 7.0696507464163e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 7.8552e-05\n", - "Epoch 483/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 7.0697e-05\n", - "Epoch 484/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 7.0697e-05\n", - "Epoch 485/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 7.0697e-05\n", - "Epoch 486/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 7.0697e-05\n", - "Epoch 487/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 7.0697e-05\n", - "Epoch 488/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0488 - learning_rate: 7.0697e-05\n", - "Epoch 489/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 7.0697e-05\n", - "Epoch 490/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 7.0697e-05\n", - "Epoch 491/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0485 - learning_rate: 7.0697e-05\n", - "Epoch 492/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 492: ReduceLROnPlateau reducing learning rate to 6.36268567177467e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 7.0697e-05\n", - "Epoch 493/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 6.3627e-05\n", - "Epoch 494/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 6.3627e-05\n", - "Epoch 495/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 6.3627e-05\n", - "Epoch 496/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 6.3627e-05\n", - "Epoch 497/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 6.3627e-05\n", - "Epoch 498/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 6.3627e-05\n", - "Epoch 499/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 6.3627e-05\n", - "Epoch 500/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 6.3627e-05\n", - "Epoch 501/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 6.3627e-05\n", - "Epoch 502/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0230\n", - "Epoch 502: ReduceLROnPlateau reducing learning rate to 5.726417366531678e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 6.3627e-05\n", - "Epoch 503/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 5.7264e-05\n", - "Epoch 504/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 5.7264e-05\n", - "Epoch 505/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 5.7264e-05\n", - "Epoch 506/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 5.7264e-05\n", - "Epoch 507/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 5.7264e-05\n", - "Epoch 508/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0491 - learning_rate: 5.7264e-05\n", - "Epoch 509/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 5.7264e-05\n", - "Epoch 510/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 5.7264e-05\n", - "Epoch 511/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 74ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 5.7264e-05\n", - "Epoch 512/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 512: ReduceLROnPlateau reducing learning rate to 5.1537755643948914e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 5.7264e-05\n", - "Epoch 513/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 5.1538e-05\n", - "Epoch 514/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 5.1538e-05\n", - "Epoch 515/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 5.1538e-05\n", - "Epoch 516/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0493 - learning_rate: 5.1538e-05\n", - "Epoch 517/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 5.1538e-05\n", - "Epoch 518/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 5.1538e-05\n", - "Epoch 519/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 5.1538e-05\n", - "Epoch 520/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0490 - learning_rate: 5.1538e-05\n", - "Epoch 521/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 5.1538e-05\n", - "Epoch 522/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 522: ReduceLROnPlateau reducing learning rate to 4.638397876988165e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 5.1538e-05\n", - "Epoch 523/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.6384e-05\n", - "Epoch 524/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.6384e-05\n", - "Epoch 525/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 4.6384e-05\n", - "Epoch 526/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 4.6384e-05\n", - "Epoch 527/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0490 - learning_rate: 4.6384e-05\n", - "Epoch 528/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 4.6384e-05\n", - "Epoch 529/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0230 - val_loss: 0.0491 - learning_rate: 4.6384e-05\n", - "Epoch 530/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 4.6384e-05\n", - "Epoch 531/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 4.6384e-05\n", - "Epoch 532/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 532: ReduceLROnPlateau reducing learning rate to 4.174558089289349e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 4.6384e-05\n", - "Epoch 533/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.1746e-05\n", - "Epoch 534/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 4.1746e-05\n", - "Epoch 535/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 4.1746e-05\n", - "Epoch 536/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.1746e-05\n", - "Epoch 537/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 72ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 4.1746e-05\n", - "Epoch 538/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0488 - learning_rate: 4.1746e-05\n", - "Epoch 539/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 4.1746e-05\n", - "Epoch 540/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 4.1746e-05\n", - "Epoch 541/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 73ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.1746e-05\n", - "Epoch 542/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 542: ReduceLROnPlateau reducing learning rate to 3.7571023131022234e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 4.1746e-05\n", - "Epoch 543/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.7571e-05\n", - "Epoch 544/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.7571e-05\n", - "Epoch 545/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.7571e-05\n", - "Epoch 546/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 3.7571e-05\n", - "Epoch 547/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 3.7571e-05\n", - "Epoch 548/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.7571e-05\n", - "Epoch 549/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0494 - learning_rate: 3.7571e-05\n", - "Epoch 550/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 3.7571e-05\n", - "Epoch 551/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 3.7571e-05\n", - "Epoch 552/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0231\n", - "Epoch 552: ReduceLROnPlateau reducing learning rate to 3.381392016308382e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 69ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 3.7571e-05\n", - "Epoch 553/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.3814e-05\n", - "Epoch 554/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.3814e-05\n", - "Epoch 555/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.3814e-05\n", - "Epoch 556/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 3.3814e-05\n", - "Epoch 557/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.3814e-05\n", - "Epoch 558/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 74ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 3.3814e-05\n", - "Epoch 559/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 3.3814e-05\n", - "Epoch 560/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 3.3814e-05\n", - "Epoch 561/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.3814e-05\n", - "Epoch 562/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 562: ReduceLROnPlateau reducing learning rate to 3.043252945644781e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 74ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 3.3814e-05\n", - "Epoch 563/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.0433e-05\n", - "Epoch 564/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.0433e-05\n", - "Epoch 565/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.0433e-05\n", - "Epoch 566/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 3.0433e-05\n", - "Epoch 567/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 74ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.0433e-05\n", - "Epoch 568/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.0433e-05\n", - "Epoch 569/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 3.0433e-05\n", - "Epoch 570/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 3.0433e-05\n", - "Epoch 571/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0492 - learning_rate: 3.0433e-05\n", - "Epoch 572/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 572: ReduceLROnPlateau reducing learning rate to 2.738927651080303e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 3.0433e-05\n", - "Epoch 573/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.7389e-05\n", - "Epoch 574/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.7389e-05\n", - "Epoch 575/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 2.7389e-05\n", - "Epoch 576/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0493 - learning_rate: 2.7389e-05\n", - "Epoch 577/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.7389e-05\n", - "Epoch 578/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.7389e-05\n", - "Epoch 579/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 2.7389e-05\n", - "Epoch 580/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 2.7389e-05\n", - "Epoch 581/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 2.7389e-05\n", - "Epoch 582/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0230\n", - "Epoch 582: ReduceLROnPlateau reducing learning rate to 2.4650348859722725e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 2.7389e-05\n", - "Epoch 583/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0230 - val_loss: 0.0490 - learning_rate: 2.4650e-05\n", - "Epoch 584/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 72ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.4650e-05\n", - "Epoch 585/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 2.4650e-05\n", - "Epoch 586/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 2.4650e-05\n", - "Epoch 587/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.4650e-05\n", - "Epoch 588/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0483 - learning_rate: 2.4650e-05\n", - "Epoch 589/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.4650e-05\n", - "Epoch 590/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.4650e-05\n", - "Epoch 591/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 2.4650e-05\n", - "Epoch 592/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.4650e-05\n", - "Epoch 593/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 2.4650e-05\n", - "Epoch 594/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 72ms/step - loss: 0.0230 - val_loss: 0.0491 - learning_rate: 2.4650e-05\n", - "Epoch 595/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 72ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 2.4650e-05\n", - "Epoch 596/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.4650e-05\n", - "Epoch 597/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.4650e-05\n", - "Epoch 598/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 598: ReduceLROnPlateau reducing learning rate to 2.218531462858664e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 2.4650e-05\n", - "Epoch 599/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 2.2185e-05\n", - "Epoch 600/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.2185e-05\n", - "Epoch 601/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 2.2185e-05\n", - "Epoch 602/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.2185e-05\n", - "Epoch 603/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0488 - learning_rate: 2.2185e-05\n", - "Epoch 604/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 2.2185e-05\n", - "Epoch 605/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.2185e-05\n", - "Epoch 606/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 72ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.2185e-05\n", - "Epoch 607/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.2185e-05\n", - "Epoch 608/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0231\n", - "Epoch 608: ReduceLROnPlateau reducing learning rate to 1.9966783656855114e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 2.2185e-05\n", - "Epoch 609/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 74ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 1.9967e-05\n", - "Epoch 610/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.9967e-05\n", - "Epoch 611/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.9967e-05\n", - "Epoch 612/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.9967e-05\n", - "Epoch 613/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.9967e-05\n", - "Epoch 614/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.9967e-05\n", - "Epoch 615/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.9967e-05\n", - "Epoch 616/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.9967e-05\n", - "Epoch 617/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.9967e-05\n", - "Epoch 618/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 618: ReduceLROnPlateau reducing learning rate to 1.7970104636333417e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.9967e-05\n", - "Epoch 619/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.7970e-05\n", - "Epoch 620/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 1.7970e-05\n", - "Epoch 621/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.7970e-05\n", - "Epoch 622/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 1.7970e-05\n", - "Epoch 623/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.7970e-05\n", - "Epoch 624/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.7970e-05\n", - "Epoch 625/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.7970e-05\n", - "Epoch 626/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.7970e-05\n", - "Epoch 627/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 1.7970e-05\n", - "Epoch 628/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0231\n", - "Epoch 628: ReduceLROnPlateau reducing learning rate to 1.6173094991245307e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 1.7970e-05\n", - "Epoch 629/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.6173e-05\n", - "Epoch 630/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.6173e-05\n", - "Epoch 631/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 1.6173e-05\n", - "Epoch 632/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.6173e-05\n", - "Epoch 633/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 72ms/step - loss: 0.0230 - val_loss: 0.0490 - learning_rate: 1.6173e-05\n", - "Epoch 634/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.6173e-05\n", - "Epoch 635/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.6173e-05\n", - "Epoch 636/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.6173e-05\n", - "Epoch 637/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.6173e-05\n", - "Epoch 638/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 638: ReduceLROnPlateau reducing learning rate to 1.4555785492120777e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 1.6173e-05\n", - "Epoch 639/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 1.4556e-05\n", - "Epoch 640/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.4556e-05\n", - "Epoch 641/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 1.4556e-05\n", - "Epoch 642/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.4556e-05\n", - "Epoch 643/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.4556e-05\n", - "Epoch 644/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.4556e-05\n", - "Epoch 645/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.4556e-05\n", - "Epoch 646/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 1.4556e-05\n", - "Epoch 647/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.4556e-05\n", - "Epoch 648/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0231\n", - "Epoch 648: ReduceLROnPlateau reducing learning rate to 1.3100206615490606e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.4556e-05\n", - "Epoch 649/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 74ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.3100e-05\n", - "Epoch 650/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 1.3100e-05\n", - "Epoch 651/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.3100e-05\n", - "Epoch 652/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.3100e-05\n", - "Epoch 653/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.3100e-05\n", - "Epoch 654/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 74ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.3100e-05\n", - "Epoch 655/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.3100e-05\n", - "Epoch 656/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.3100e-05\n", - "Epoch 657/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 1.3100e-05\n", - "Epoch 658/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 658: ReduceLROnPlateau reducing learning rate to 1.1790186363214161e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.3100e-05\n", - "Epoch 659/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 72ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.1790e-05\n", - "Epoch 660/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 1.1790e-05\n", - "Epoch 661/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 1.1790e-05\n", - "Epoch 662/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 1.1790e-05\n", - "Epoch 663/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.1790e-05\n", - "Epoch 664/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.1790e-05\n", - "Epoch 665/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.1790e-05\n", - "Epoch 666/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.1790e-05\n", - "Epoch 667/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.1790e-05\n", - "Epoch 668/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 668: ReduceLROnPlateau reducing learning rate to 1.0611167726892746e-05.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 1.1790e-05\n", - "Epoch 669/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.0611e-05\n", - "Epoch 670/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.0611e-05\n", - "Epoch 671/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 1.0611e-05\n", - "Epoch 672/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 1.0611e-05\n", - "Epoch 673/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.0611e-05\n", - "Epoch 674/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.0611e-05\n", - "Epoch 675/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.0611e-05\n", - "Epoch 676/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 1.0611e-05\n", - "Epoch 677/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 1.0611e-05\n", - "Epoch 678/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 678: ReduceLROnPlateau reducing learning rate to 9.550050708639902e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 1.0611e-05\n", - "Epoch 679/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 9.5501e-06\n", - "Epoch 680/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 9.5501e-06\n", - "Epoch 681/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 9.5501e-06\n", - "Epoch 682/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 9.5501e-06\n", - "Epoch 683/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 9.5501e-06\n", - "Epoch 684/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-20 03:50:00.178953: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n", - "\t [[{{node MultiDeviceIteratorGetNextFromShard}}]]\n", - "\t [[RemoteCall]]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 9.5501e-06\n", - "Epoch 685/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 9.5501e-06\n", - "Epoch 686/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 9.5501e-06\n", - "Epoch 687/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 9.5501e-06\n", - "Epoch 688/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 688: ReduceLROnPlateau reducing learning rate to 8.595045801484958e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 9.5501e-06\n", - "Epoch 689/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 8.5950e-06\n", - "Epoch 690/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 8.5950e-06\n", - "Epoch 691/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 74ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 8.5950e-06\n", - "Epoch 692/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 8.5950e-06\n", - "Epoch 693/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 8.5950e-06\n", - "Epoch 694/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 8.5950e-06\n", - "Epoch 695/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 8.5950e-06\n", - "Epoch 696/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 8.5950e-06\n", - "Epoch 697/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 8.5950e-06\n", - "Epoch 698/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 698: ReduceLROnPlateau reducing learning rate to 7.735541385045509e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 8.5950e-06\n", - "Epoch 699/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 7.7355e-06\n", - "Epoch 700/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 7.7355e-06\n", - "Epoch 701/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 7.7355e-06\n", - "Epoch 702/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 7.7355e-06\n", - "Epoch 703/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 7.7355e-06\n", - "Epoch 704/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 7.7355e-06\n", - "Epoch 705/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 7.7355e-06\n", - "Epoch 706/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 7.7355e-06\n", - "Epoch 707/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 7.7355e-06\n", - "Epoch 708/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 708: ReduceLROnPlateau reducing learning rate to 6.961987492104527e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 7.7355e-06\n", - "Epoch 709/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 6.9620e-06\n", - "Epoch 710/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 6.9620e-06\n", - "Epoch 711/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0230 - val_loss: 0.0491 - learning_rate: 6.9620e-06\n", - "Epoch 712/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 6.9620e-06\n", - "Epoch 713/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 6.9620e-06\n", - "Epoch 714/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 6.9620e-06\n", - "Epoch 715/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 6.9620e-06\n", - "Epoch 716/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 6.9620e-06\n", - "Epoch 717/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 6.9620e-06\n", - "Epoch 718/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0230\n", - "Epoch 718: ReduceLROnPlateau reducing learning rate to 6.265788579185028e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 6.9620e-06\n", - "Epoch 719/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 72ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 6.2658e-06\n", - "Epoch 720/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 72ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 6.2658e-06\n", - "Epoch 721/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 6.2658e-06\n", - "Epoch 722/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 6.2658e-06\n", - "Epoch 723/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 6.2658e-06\n", - "Epoch 724/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 6.2658e-06\n", - "Epoch 725/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0486 - learning_rate: 6.2658e-06\n", - "Epoch 726/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0491 - learning_rate: 6.2658e-06\n", - "Epoch 727/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 6.2658e-06\n", - "Epoch 728/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 728: ReduceLROnPlateau reducing learning rate to 5.639209803121048e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 6.2658e-06\n", - "Epoch 729/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 5.6392e-06\n", - "Epoch 730/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0230 - val_loss: 0.0490 - learning_rate: 5.6392e-06\n", - "Epoch 731/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 5.6392e-06\n", - "Epoch 732/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 5.6392e-06\n", - "Epoch 733/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 5.6392e-06\n", - "Epoch 734/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0489 - learning_rate: 5.6392e-06\n", - "Epoch 735/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 5.6392e-06\n", - "Epoch 736/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 5.6392e-06\n", - "Epoch 737/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0490 - learning_rate: 5.6392e-06\n", - "Epoch 738/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 738: ReduceLROnPlateau reducing learning rate to 5.075289027445251e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 5.6392e-06\n", - "Epoch 739/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 79ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 5.0753e-06\n", - "Epoch 740/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0487 - learning_rate: 5.0753e-06\n", - "Epoch 741/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 5.0753e-06\n", - "Epoch 742/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 5.0753e-06\n", - "Epoch 743/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 72ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 5.0753e-06\n", - "Epoch 744/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 5.0753e-06\n", - "Epoch 745/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 5.0753e-06\n", - "Epoch 746/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 78ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 5.0753e-06\n", - "Epoch 747/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 5.0753e-06\n", - "Epoch 748/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 748: ReduceLROnPlateau reducing learning rate to 4.567760288409772e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 5.0753e-06\n", - "Epoch 749/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 4.5678e-06\n", - "Epoch 750/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 4.5678e-06\n", - "Epoch 751/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.5678e-06\n", - "Epoch 752/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 4.5678e-06\n", - "Epoch 753/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 4.5678e-06\n", - "Epoch 754/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 4.5678e-06\n", - "Epoch 755/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.5678e-06\n", - "Epoch 756/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 4.5678e-06\n", - "Epoch 757/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 4.5678e-06\n", - "Epoch 758/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 758: ReduceLROnPlateau reducing learning rate to 4.110984218641534e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 73ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.5678e-06\n", - "Epoch 759/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 4.1110e-06\n", - "Epoch 760/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.1110e-06\n", - "Epoch 761/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.1110e-06\n", - "Epoch 762/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.1110e-06\n", - "Epoch 763/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 4.1110e-06\n", - "Epoch 764/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 4.1110e-06\n", - "Epoch 765/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 4.1110e-06\n", - "Epoch 766/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 4.1110e-06\n", - "Epoch 767/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 4.1110e-06\n", - "Epoch 768/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 768: ReduceLROnPlateau reducing learning rate to 3.6998858377046417e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0488 - learning_rate: 4.1110e-06\n", - "Epoch 769/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.6999e-06\n", - "Epoch 770/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.6999e-06\n", - "Epoch 771/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 3.6999e-06\n", - "Epoch 772/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.6999e-06\n", - "Epoch 773/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.6999e-06\n", - "Epoch 774/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0493 - learning_rate: 3.6999e-06\n", - "Epoch 775/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 3.6999e-06\n", - "Epoch 776/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 3.6999e-06\n", - "Epoch 777/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0230 - val_loss: 0.0490 - learning_rate: 3.6999e-06\n", - "Epoch 778/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0231\n", - "Epoch 778: ReduceLROnPlateau reducing learning rate to 3.3298972539341776e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 3.6999e-06\n", - "Epoch 779/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.3299e-06\n", - "Epoch 780/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.3299e-06\n", - "Epoch 781/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 3.3299e-06\n", - "Epoch 782/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 3.3299e-06\n", - "Epoch 783/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 3.3299e-06\n", - "Epoch 784/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0492 - learning_rate: 3.3299e-06\n", - "Epoch 785/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0487 - learning_rate: 3.3299e-06\n", - "Epoch 786/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 73ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.3299e-06\n", - "Epoch 787/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 72ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 3.3299e-06\n", - "Epoch 788/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - loss: 0.0230\n", - "Epoch 788: ReduceLROnPlateau reducing learning rate to 2.99690752854076e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 3.3299e-06\n", - "Epoch 789/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0490 - learning_rate: 2.9969e-06\n", - "Epoch 790/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.9969e-06\n", - "Epoch 791/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0232 - val_loss: 0.0491 - learning_rate: 2.9969e-06\n", - "Epoch 792/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.9969e-06\n", - "Epoch 793/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.9969e-06\n", - "Epoch 794/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0489 - learning_rate: 2.9969e-06\n", - "Epoch 795/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 76ms/step - loss: 0.0231 - val_loss: 0.0486 - learning_rate: 2.9969e-06\n", - "Epoch 796/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 71ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.9969e-06\n", - "Epoch 797/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.9969e-06\n", - "Epoch 798/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - loss: 0.0230\n", - "Epoch 798: ReduceLROnPlateau reducing learning rate to 2.697216837077576e-06.\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 75ms/step - loss: 0.0231 - val_loss: 0.0488 - learning_rate: 2.9969e-06\n", - "Epoch 799/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 70ms/step - loss: 0.0231 - val_loss: 0.0491 - learning_rate: 2.6972e-06\n", - "Epoch 800/800\n", - "\u001b[1m400/400\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 70ms/step - loss: 0.0232 - val_loss: 0.0489 - learning_rate: 2.6972e-06\n" - ] - } - ], - "source": [ - "\n", - "# Train the model\n", - "history = model_builder.train_model(\n", - " train_dataset, \n", - " val_dataset, \n", - " epochs=800,\n", - " callbacks_list=[lr_scheduler]\n", - ")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAJOCAYAAADWJO1qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3wUxfvHP3t36Qm9JQhBOqEkFEFAWogiagQrP+ArRbCGryBi+6qAgGBBRREBEYmASESKhRqQIqEHQhGkJhBIKCEkkJ67nd8fl7vs7u3e7d1tckl43q9X4G5vdma2zTz7tOEYYwwEQRAEQRAEoQKdpztAEARBEARBVB5IeCQIgiAIgiBUQ8IjQRAEQRAEoRoSHgmCIAiCIAjVkPBIEARBEARBqIaER4IgCIIgCEI1JDwSBEEQBEEQqiHhkSAIgiAIglANCY8EQRAEQRCEakh4JAiiwjFq1Cg0adLEpX2nTp0KjuO07VAFIyUlBRzHITY2ttzb5jgOU6dOtX6PjY0Fx3FISUlxuG+TJk0watQoTfvjzr1CEIRrkPBIEIRqOI5T9bdjxw5Pd/Wu57XXXgPHcTh37pximffeew8cx+HYsWPl2DPnSUtLw9SpU5GUlOTprlixCPCzZ8/2dFcIotwxeLoDBEFUHpYtWyb6vnTpUsTHx9tsb9OmjVvtLFq0CDzPu7Tv+++/j3feecet9qsCw4cPx9y5c7FixQpMnjxZtszPP/+M9u3bo0OHDi6389xzz+H//u//4OPj43IdjkhLS8OHH36IJk2aICIiQvSbO/cKQRCuQcIjQRCq+c9//iP6vm/fPsTHx9tsl5KXlwd/f3/V7Xh5ebnUPwAwGAwwGGho69atG5o3b46ff/5ZVnjcu3cvkpOT8fHHH7vVjl6vh16vd6sOd3DnXiEIwjXIbE0QhKb07dsX7dq1Q2JiInr37g1/f3/873//AwD89ttvePTRRxESEgIfHx80a9YM06dPh8lkEtUh9WMTmgi/++47NGvWDD4+Prjvvvtw8OBB0b5yPo8cx2HcuHFYt24d2rVrBx8fH7Rt2xabNm2y6f+OHTvQpUsX+Pr6olmzZli4cKFqP8q///4bzzzzDBo3bgwfHx80atQIr7/+OvLz822OLzAwEFeuXMHgwYMRGBiIunXrYtKkSTbnIisrC6NGjUL16tVRo0YNjBw5EllZWQ77Api1j//++y8OHz5s89uKFSvAcRyGDh2KoqIiTJ48GZ07d0b16tUREBCAXr16Yfv27Q7bkPN5ZIxhxowZuOeee+Dv749+/frhn3/+sdk3MzMTkyZNQvv27REYGIhq1aph4MCBOHr0qLXMjh07cN999wEARo8ebXWNsPh7yvk85ubm4o033kCjRo3g4+ODVq1aYfbs2WCMico5c1+4yvXr1zFmzBjUr18fvr6+CA8Px48//mhTbuXKlejcuTOCgoJQrVo1tG/fHl999ZX19+LiYnz44Ydo0aIFfH19Ubt2bTzwwAOIj4/XrK8EoRZ6PScIQnNu3ryJgQMH4v/+7//wn//8B/Xr1wdgFjQCAwMxceJEBAYG4q+//sLkyZNx+/ZtfPbZZw7rXbFiBe7cuYOXXnoJHMfh008/xZNPPokLFy441EDt3r0ba9aswauvvoqgoCB8/fXXeOqpp3Dp0iXUrl0bAHDkyBE8/PDDCA4OxocffgiTyYRp06ahbt26qo571apVyMvLwyuvvILatWvjwIEDmDt3Li5fvoxVq1aJyppMJgwYMADdunXD7NmzsXXrVnz++edo1qwZXnnlFQBmIWzQoEHYvXs3Xn75ZbRp0wZr167FyJEjVfVn+PDh+PDDD7FixQp06tRJ1PYvv/yCXr16oXHjxsjIyMD333+PoUOH4oUXXsCdO3ewePFiDBgwAAcOHLAxFTti8uTJmDFjBh555BE88sgjOHz4MB566CEUFRWJyl24cAHr1q3DM888g3vvvRfXrl3DwoUL0adPH5w8eRIhISFo06YNpk2bhsmTJ+PFF19Er169AAA9evSQbZsxhscffxzbt2/HmDFjEBERgc2bN+PNN9/ElStX8OWXX4rKq7kvXCU/Px99+/bFuXPnMG7cONx7771YtWoVRo0ahaysLIwfPx4AEB8fj6FDh6J///745JNPAACnTp1CQkKCtczUqVMxa9YsjB07Fl27dsXt27dx6NAhHD58GA8++KBb/SQIp2EEQRAuEhMTw6TDSJ8+fRgAtmDBApvyeXl5Ntteeukl5u/vzwoKCqzbRo4cyUJDQ63fk5OTGQBWu3ZtlpmZad3+22+/MQDsjz/+sG6bMmWKTZ8AMG9vb3bu3DnrtqNHjzIAbO7cudZt0dHRzN/fn125csW67ezZs8xgMNjUKYfc8c2aNYtxHMcuXrwoOj4AbNq0aaKyHTt2ZJ07d7Z+X7duHQPAPv30U+s2o9HIevXqxQCwJUuWOOzTfffdx+655x5mMpms2zZt2sQAsIULF1rrLCwsFO1369YtVr9+ffb888+LtgNgU6ZMsX5fsmQJA8CSk5MZY4xdv36deXt7s0cffZTxPG8t97///Y8BYCNHjrRuKygoEPWLMfO19vHxEZ2bgwcPKh6v9F6xnLMZM2aIyj399NOM4zjRPaD2vpDDck9+9tlnimXmzJnDALDly5dbtxUVFbHu3buzwMBAdvv2bcYYY+PHj2fVqlVjRqNRsa7w8HD26KOP2u0TQZQXZLYmCEJzfHx8MHr0aJvtfn5+1s937txBRkYGevXqhby8PPz7778O6x0yZAhq1qxp/W7RQl24cMHhvlFRUWjWrJn1e4cOHVCtWjXrviaTCVu3bsXgwYMREhJiLde8eXMMHDjQYf2A+Phyc3ORkZGBHj16gDGGI0eO2JR/+eWXRd979eolOpYNGzbAYDBYNZGA2cfwv//9r6r+AGY/1cuXL2PXrl3WbStWrIC3tzeeeeYZa53e3t4AAJ7nkZmZCaPRiC5dusiavO2xdetWFBUV4b///a/I1D9hwgSbsj4+PtDpzNOQyWTCzZs3ERgYiFatWjndroUNGzZAr9fjtddeE21/4403wBjDxo0bRdsd3RfusGHDBjRo0ABDhw61bvPy8sJrr72GnJwc7Ny5EwBQo0YN5Obm2jVB16hRA//88w/Onj3rdr8Iwl1IeCQIQnMaNmxoFUaE/PPPP3jiiSdQvXp1VKtWDXXr1rUG22RnZzust3HjxqLvFkHy1q1bTu9r2d+y7/Xr15Gfn4/mzZvblJPbJselS5cwatQo1KpVy+rH2KdPHwC2x+fr62tjDhf2BwAuXryI4OBgBAYGisq1atVKVX8A4P/+7/+g1+uxYsUKAEBBQQHWrl2LgQMHigTxH3/8ER06dLD609WtWxfr169XdV2EXLx4EQDQokUL0fa6deuK2gPMguqXX36JFi1awMfHB3Xq1EHdunVx7Ngxp9sVth8SEoKgoCDRdksGAEv/LDi6L9zh4sWLaNGihVVAVurLq6++ipYtW2LgwIG455578Pzzz9v4XU6bNg1ZWVlo2bIl2rdvjzfffLPCp1giqi4kPBIEoTlCDZyFrKws9OnTB0ePHsW0adPwxx9/ID4+3urjpSbdilJUL5MEQmi9rxpMJhMefPBBrF+/Hm+//TbWrVuH+Ph4a2CH9PjKK0K5Xr16ePDBB7F69WoUFxfjjz/+wJ07dzB8+HBrmeXLl2PUqFFo1qwZFi9ejE2bNiE+Ph6RkZFlmgZn5syZmDhxInr37o3ly5dj8+bNiI+PR9u2bcst/U5Z3xdqqFevHpKSkvD7779b/TUHDhwo8m3t3bs3zp8/jx9++AHt2rXD999/j06dOuH7778vt34ShAUKmCEIolzYsWMHbt68iTVr1qB3797W7cnJyR7sVSn16tWDr6+vbFJte4m2LRw/fhxnzpzBjz/+iBEjRli3uxMNGxoaim3btiEnJ0ekfTx9+rRT9QwfPhybNm3Cxo0bsWLFClSrVg3R0dHW33/99Vc0bdoUa9asEZmap0yZ4lKfAeDs2bNo2rSpdfuNGzdstHm//vor+vXrh8WLF4u2Z2VloU6dOtbvzqwYFBoaiq1bt+LOnTsi7aPFLcLSv/IgNDQUx44dA8/zIu2jXF+8vb0RHR2N6Oho8DyPV199FQsXLsQHH3xg1XzXqlULo0ePxujRo5GTk4PevXtj6tSpGDt2bLkdE0EApHkkCKKcsGh4hBqdoqIifPvtt57qkgi9Xo+oqCisW7cOaWlp1u3nzp2z8ZNT2h8QHx9jTJRuxVkeeeQRGI1GzJ8/37rNZDJh7ty5TtUzePBg+Pv749tvv8XGjRvx5JNPwtfX127f9+/fj7179zrd56ioKHh5eWHu3Lmi+ubMmWNTVq/X22j4Vq1ahStXroi2BQQEAICqFEWPPPIITCYTvvnmG9H2L7/8EhzHqfZf1YJHHnkEV69eRVxcnHWb0WjE3LlzERgYaHVpuHnzpmg/nU5nTdxeWFgoWyYwMBDNmze3/k4Q5QlpHgmCKBd69OiBmjVrYuTIkdal85YtW1au5kFHTJ06FVu2bEHPnj3xyiuvWIWQdu3aOVwar3Xr1mjWrBkmTZqEK1euoFq1ali9erVbvnPR0dHo2bMn3nnnHaSkpCAsLAxr1qxx2h8wMDAQgwcPtvo9Ck3WAPDYY49hzZo1eOKJJ/Doo48iOTkZCxYsQFhYGHJycpxqy5KvctasWXjsscfwyCOP4MiRI9i4caNIm2hpd9q0aRg9ejR69OiB48eP46effhJpLAGgWbNmqFGjBhYsWICgoCAEBASgW7duuPfee23aj46ORr9+/fDee+8hJSUF4eHh2LJlC3777TdMmDBBFByjBdu2bUNBQYHN9sGDB+PFF1/EwoULMWrUKCQmJqJJkyb49ddfkZCQgDlz5lg1o2PHjkVmZiYiIyNxzz334OLFi5g7dy4iIiKs/pFhYWHo27cvOnfujFq1auHQoUP49ddfMW7cOE2PhyBU4Zkgb4IgqgJKqXratm0rWz4hIYHdf//9zM/Pj4WEhLC33nqLbd68mQFg27dvt5ZTStUjlxYFktQxSql6YmJibPYNDQ0VpY5hjLFt27axjh07Mm9vb9asWTP2/fffszfeeIP5+voqnIVSTp48yaKiolhgYCCrU6cOe+GFF6ypX4RpZkaOHMkCAgJs9pfr+82bN9lzzz3HqlWrxqpXr86ee+45duTIEdWpeiysX7+eAWDBwcE26XF4nmczZ85koaGhzMfHh3Xs2JH9+eefNteBMcepehhjzGQysQ8//JAFBwczPz8/1rdvX3bixAmb811QUMDeeOMNa7mePXuyvXv3sj59+rA+ffqI2v3tt99YWFiYNW2S5djl+njnzh32+uuvs5CQEObl5cVatGjBPvvsM1HqIMuxqL0vpFjuSaW/ZcuWMcYYu3btGhs9ejSrU6cO8/b2Zu3bt7e5br/++it76KGHWL169Zi3tzdr3Lgxe+mll1h6erq1zIwZM1jXrl1ZjRo1mJ+fH2vdujX76KOPWFFRkd1+EkRZwDFWgV77CYIgKiCDBw+mNCkEQRAlkM8jQRCEAOlSgmfPnsWGDRvQt29fz3SIIAiigkGaR4IgCAHBwcEYNWoUmjZtiosXL2L+/PkoLCzEkSNHbHIXEgRB3I1QwAxBEISAhx9+GD///DOuXr0KHx8fdO/eHTNnziTBkSAIogTSPBIEQRAEQRCqIZ9HgiAIgiAIQjUkPBIEQRAEQRCqIZ/HuxSe55GWloagoCCnlv4iCIIgCKJqwhjDnTt3EBISIlpSUwoJj3cpaWlpaNSokae7QRAEQRBEBSM1NRX33HOP4u8kPFZyUlNT8dxzz+H69eswGAz44IMP8Mwzzzjcz7IsVmpqKqpVq1bW3SQIgiAIooJz+/ZtNGrUyCojKEHR1pWc9PR0XLt2DREREbh69So6d+6MM2fOICAgwO5+t2/fRvXq1ZGdnU3CI0EQBEEQqmUD0jxWcoKDgxEcHAwAaNCgAerUqYPMzEyHwiNBEARBEIQr3LXR1lOnTgXHcaK/1q1ba9rGrl27EB0djZCQEHAch3Xr1smWmzdvHpo0aQJfX19069YNBw4ccKm9xMREmEwm8mUkCIIgCKLMuGuFRwBo27Yt0tPTrX+7d+9WLJuQkIDi4mKb7SdPnsS1a9dk98nNzUV4eDjmzZunWG9cXBwmTpyIKVOm4PDhwwgPD8eAAQNw/fp1a5mIiAi0a9fO5i8tLc1aJjMzEyNGjMB3332n5tAJgiAIgiBc4q42WxsMBjRo0MBhOZ7nERMTgxYtWmDlypXQ6/UAgNOnTyMyMhITJ07EW2+9ZbPfwIEDMXDgQLt1f/HFF3jhhRcwevRoAMCCBQuwfv16/PDDD3jnnXcAAElJSXbrKCwsxODBg/HOO++gR48eDo+HIAhtMJlMsi+VBEEQFREvLy+rDOMOd7XwePbsWYSEhMDX1xfdu3fHrFmz0LhxY5tyOp0OGzZsQO/evTFixAgsW7YMycnJiIyMxODBg2UFRzUUFRUhMTER7777rqitqKgo7N27V1UdjDGMGjUKkZGReO655xyWnzdvHubNmweTyeRSnwmCMD93V69eRVZWlqe7QhAE4RQ1atRAgwYN3MrxfNcKj926dUNsbCxatWqF9PR0fPjhh+jVqxdOnDghG6IeEhKCv/76C7169cKwYcOwd+9eREVFYf78+S73ISMjAyaTCfXr1xdtr1+/Pv79919VdSQkJCAuLg4dOnSw+lQuW7YM7du3ly0fExODmJgYa0QVQRDOYxEc69WrB39/f0q0TxBEhYcxhry8PKtbnCXY1hXuWuFRaE7u0KEDunXrhtDQUPzyyy8YM2aM7D6NGzfGsmXL0KdPHzRt2hSLFy/2+KTxwAMPgOd5j/aBIO4mTCaTVXCsXbu2p7tDEAShGj8/PwDA9evXUa9ePZdN2Hd1wIyQGjVqoGXLljh37pximWvXruHFF19EdHQ08vLy8Prrr7vVZp06daDX620Cbq5du6bKF5MgiPLH4uPo7+/v4Z4QBEE4j2Xscsdfm4THEnJycnD+/HlFNW5GRgb69++PNm3aYM2aNdi2bRvi4uIwadIkl9v09vZG586dsW3bNus2nuexbds2dO/e3eV6CYIoezxtdSAIgnAFLcauu9ZsPWnSJERHRyM0NBRpaWmYMmUK9Ho9hg4dalOW53kMHDgQoaGhiIuLg8FgQFhYGOLj4xEZGYmGDRvKaiFzcnJEmszk5GQkJSWhVq1a1sCciRMnYuTIkejSpQu6du2KOXPmIDc31xp9TRAEQRAEUZG4azWPly9fxtChQ9GqVSs8++yzqF27Nvbt24e6devalNXpdJg5cyZWr14Nb29v6/bw8HBs3bpVcS3pQ4cOoWPHjujYsSMAs6DYsWNHTJ482VpmyJAhmD17NiZPnoyIiAgkJSVh06ZNNkE0BEEQFZEmTZpgzpw5nu5GpWXq1KmIiIiwW2bUqFEYPHiwpu3GxsaiRo0amtZZEbC3IAehHbS29V0KrW1NEK5RUFCA5ORk3HvvvfD19fV0d1TjyFQ1ZcoUTJ061el6b9y4gYCAALd8QPv27YuIiIi7UgjNyclBYWGh3eCrUaNGISsrS1OhKD8/H3fu3EG9evVU71MZrhPHcVi7dq3mwnZVwt4YRmtbEwRBEFbS09Otn+Pi4jB58mScPn3aui0wMND6mTEGk8kEg8HxFCFnrSHUExgYKDr35YWfn5818raiUFxcDC8vL093g1DBXWu2JgiCuJto0KCB9a969ergOM76/d9//0VQUBA2btyIzp07w8fHB7t378b58+cxaNAg1K9fH4GBgbjvvvuwdetWUb1SszXHcfj+++/xxBNPwN/fHy1atMDvv//uVt9Xr16Ntm3bwsfHB02aNMHnn38u+v3bb79FixYt4Ovri/r16+Ppp5+2/vbrr7+iffv28PPzQ+3atREVFYXc3FzZdqZNm4aQkBDcvHnTuu3RRx9Fv379VKVE4zgOCxcuxGOPPQZ/f3+0adMGe/fuxblz59C3b18EBASgR48eOH/+vHUfqdnaZDJh4sSJqFGjBmrXro233noLUgNh3759MW7cOIwbNw7Vq1dHnTp18MEHH4jK3bp1CyNGjEDNmjXh7++PgQMH4uzZs9bfpWZrSz+WLVuGJk2aoHr16vi///s/3LlzB4BZ+7lz50589dVX4DgOHMchJSUFt27dwvDhw1G3bl34+fmhRYsWWLJkicNzlZKSAo7jEBcXhz59+sDX1xc//fQTAOD7779HmzZt4Ovri9atW+Pbb7+17ldUVIRx48YhODgYvr6+CA0NxaxZs0R1Z2RkKN5/JpMJY8aMwb333gs/Pz+0atUKX331lWh/i5vAhx9+iLp166JatWp4+eWXUVRUZC3D8zxmzZplrSc8PBy//vqrw+OuMjDiriQ7O5sBYNnZ2Z7uCkFUKvLz89nJkydZfn6+dRvP8yy3sLjc/3ied+kYlixZwqpXr279vn37dgaAdejQgW3ZsoWdO3eO3bx5kyUlJbEFCxaw48ePszNnzrD333+f+fr6sosXL1r3DQ0NZV9++aX1OwB2zz33sBUrVrCzZ8+y1157jQUGBrKbN28q9qdPnz5s/Pjxsr8dOnSI6XQ6Nm3aNHb69Gm2ZMkS5ufnx5YsWcIYY+zgwYNMr9ezFStWsJSUFHb48GH21VdfMcYYS0tLYwaDgX3xxRcsOTmZHTt2jM2bN4/duXNHti2j0ci6d+/OBg8ezBhj7JtvvmE1atQQHa89ALCGDRuyuLg4dvr0aTZ48GDWpEkTFhkZyTZt2sROnjzJ7r//fvbwww9b95kyZQoLDw+3fv/kk09YzZo12erVq9nJkyfZmDFjWFBQEBs0aJDofAUGBrLx48ezf//9ly1fvpz5+/uz7777zlrm8ccfZ23atGG7du1iSUlJbMCAAax58+asqKiIMWZ7D0yZMoUFBgayJ598kh0/fpzt2rWLNWjQgP3vf/9jjDGWlZXFunfvzl544QWWnp7O0tPTmdFoZDExMSwiIoIdPHiQJScns/j4ePb77787PFfJyckMAGvSpAlbvXo1u3DhAktLS2PLly9nwcHB1m2rV69mtWrVYrGxsYwxxj777DPWqFEjtmvXLpaSksL+/vtvtmLFCtE1sHf/FRUVscmTJ7ODBw+yCxcuWM9dXFyctY6RI0eywMBANmTIEHbixAn2559/srp161rPBWOMzZgxg7Vu3Zpt2rSJnT9/ni1ZsoT5+PiwHTt2ODx2TyM3hllQKxuQ8HiXQsIjQbiG3MCbW1jMQt/+s9z/cguLXToGJeFx3bp1Dvdt27Ytmzt3rvW7nPD4/vvvW7/n5OQwAGzjxo2KddoTHocNG8YefPBB0bY333yThYWFMcYYW716NatWrRq7ffu2zb6JiYkMAEtJSXF4XBbOnz/PgoKC2Ntvv838/PzYTz/9pHpf6bHv3buXAWCLFy+2bvv555+Zr6+v9btUeAwODmaffvqp9XtxcTG75557bITHNm3aiF4e3n77bdamTRvGGGNnzpxhAFhCQoL194yMDObn58d++eUXxpi88Ojv7y86j2+++Sbr1q2bqF3pdYqOjmajR492dGpssAiPc+bMEW1v1qyZSBhkjLHp06ez7t27M8YY++9//8siIyMVX5xcuf9iYmLYU089Zf0+cuRIVqtWLZabm2vdNn/+fBYYGMhMJhMrKChg/v7+bM+ePaJ6xowZw4YOHergyD2PFsIjma0JgiAIAECXLl1E33NycjBp0iS0adMGNWrUQGBgIE6dOoVLly7ZradDhw7WzwEBAahWrZp1STRnOXXqFHr27Cna1rNnT5w9exYmkwkPPvggQkND0bRpUzz33HP46aefkJeXB8CcEaN///5o3749nnnmGSxatAi3bt2y217Tpk0xe/ZsfPLJJ3j88ccxbNgwp/orPHZL1gzhcrH169dHQUEBbt++bbNvdnY20tPT0a1bN+s2g8Fgc10A4P777xcFQXXv3t16Tk6dOgWDwSCqp3bt2mjVqhVOnTql2PcmTZqIlucNDg52eN1eeeUVrFy5EhEREXjrrbewZ88eu+WlCI8tNzcX58+fx5gxY6y+oIGBgZgxY4bV1D9q1CgkJSWhVatWeO2117BlyxabOh3df/PmzUPnzp1Rt25dBAYG4rvvvrO5p8PDw0VBYN27d0dOTg5SU1Nx7tw55OXl4cEHHxT1c+nSpSKXhKoMBcwQBEG4iZ+XHienDfBIu1oSEBAg+j5p0iTEx8dj9uzZaN68Ofz8/PD000+LfL/kkAY9cBxXZsuoBgUF4fDhw9ixYwe2bNmCyZMnY+rUqTh48CBq1KiB+Ph47NmzB1u2bMHcuXPx3nvvYf/+/bj33nsV69y1axf0ej1SUlJgNBpVBQ5ZEB67RbiT21YRl5V15boNHDgQFy9exIYNGxAfH4/+/fsjJiYGs2fPVtWm8J7LyckBACxatEgk+AKwLqPXqVMnJCcnY+PGjdi6dSueffZZREVFifwN7R3HypUrMWnSJHz++efo3r07goKC8Nlnn2H//v2q+ivs5/r169GwYUPRbz4+PqrrqcyQ5pEgCMJNOI6Dv7eh3P/KepWbhIQEjBo1Ck888QTat2+PBg0aICUlpUzblNKmTRskJCTY9Ktly5ZWgcJgMCAqKgqffvopjh07hpSUFPz1118AzNemZ8+e+PDDD3HkyBF4e3tj7dq1iu3FxcVhzZo12LFjBy5duoTp06eX3cFJqF69OoKDg0WCjNFoRGJiok1ZqbCzb98+tGjRAnq9Hm3atIHRaBSVuXnzJk6fPo2wsDCX++ft7Q2TyWSzvW7duhg5ciSWL1+OOXPm4LvvvnOp/vr16yMkJAQXLlxA8+bNRX9CYb9atWoYMmQIFi1ahLi4OKxevRqZmZmq2khISECPHj3w6quvomPHjmjevLmstvDo0aPIz8+3ft+3bx8CAwPRqFEjhIWFwcfHB5cuXbLpZ6NGjVw69soGaR4JzYk7eAkrDqRiQNv6eLVvc093hyAIF2nRogXWrFmD6OhocByHDz74oMw0Zjdu3EBSUpJoW3BwMN544w3cd999mD59OoYMGYK9e/fim2++sUbg/vnnn7hw4QJ69+6NmjVrYsOGDeB5Hq1atcL+/fuxbds2PPTQQ6hXrx7279+PGzduoE2bNrJ9uHz5Ml555RV88skneOCBB7BkyRI89thjGDhwIO6///4yOW4p48ePx8cff4wWLVqgdevW+OKLL5CVlWVT7tKlS5g4cSJeeuklHD58GHPnzrVGobdo0QKDBg3CCy+8gIULFyIoKAjvvPMOGjZsiEGDBrnctyZNmmD//v1ISUlBYGAgatWqhalTp6Jz585o27YtCgsL8eeffyqeXzV8+OGHeO2111C9enU8/PDDKCwsxKFDh3Dr1i1MnDgRX3zxBYKDg9GxY0fodDqsWrUKDRo0UJ3wvEWLFli6dCk2b96Me++9F8uWLcPBgwdtNNFFRUUYM2YM3n//faSkpGDKlCkYN24cdDodgoKCMGnSJLz++uvgeR4PPPAAsrOzkZCQgGrVqmHkyJEuH39lgYRHQnOuZhfiaGoWwoIp+ThBVGa++OILPP/88+jRowfq1KmDt99+W9ZXTwtWrFiBFStWiLZNnz4d77//Pn755RdMnjwZ06dPR3BwMKZNm4ZRo0YBAGrUqIE1a9Zg6tSpKCgoQIsWLfDzzz+jbdu2OHXqFHbt2oU5c+bg9u3bCA0Nxeeff46BAwfatM8Yw6hRo9C1a1eMGzcOADBgwAC88sor+M9//oOkpKRyycf4xhtvID09HSNHjoROp8Pzzz+PJ554AtnZ2aJyI0aMQH5+Prp27Qq9Xo/x48fjxRdftP6+ZMkSjB8/Ho899hiKiorQu3dvbNiwwa08ipMmTcLIkSMRFhaG/Px8JCcnw9vbG++++y5SUlLg5+eHXr16YeXKlS63MXbsWPj7++Ozzz7Dm2++iYCAALRv3x4TJkwAYHZT+PTTT3H27Fno9Xrcd9992LBhA3Q6dYbUl156CUeOHMGQIUPAcRyGDh2KV199FRs3bhSV69+/P1q0aIHevXujsLAQQ4cOFSXRnz59OurWrYtZs2bhwoULqFGjBjp16oT//e9/Lh97ZYJWmLlLKcsVZr7edhZfxJ/B0K6NMevJ9o53IIhKRGVdYYaoOlSGlV4qM2Wxok9FQosVZsjnkShD6L2EIAiCIKoaJDwSmlO2LvwEQRDlz08//SRKyyL8a9u2rae7V+GYOXOm4vmScxsgKhfk80iUGeQQQRBEVeHxxx+3SR9jobzXY96xY0e5tucKL7/8Mp599lnZ3yramtpSYmNjPd2FCg8Jj4TmlHH2EIIgiHInKChIlECbsE+tWrVQq1YtT3eDKCPIbE2UGaR5JAiCIIiqBwmPhOZYEhczCpghCIIgiCoHCY8EQRAEQRCEakh4JMoMMlsTBEEQRNWDhEdCcyhghiAIgiCqLiQ8EmUGKR4JourRt29f61JxgHm9Y0crnXAcp8lqHVrVQ8iTkpICjuNs1hgXsmPHDnAcJ7vetjtUxWs7atQoDB482NPdKBNIeCQ0h6M04QRR4YiOjsbDDz8s+9vff/8NjuNw7Ngxp+s9ePCgaE1lLZg6dSoiIiJstqenp5d5gunY2FjUqFGjTNuoqDRq1Ajp6elo165dubft7LW9m69TRYCER6LMIJ9Hgqg4jBkzBvHx8bh8+bLNb0uWLEGXLl3QoUMHp+utW7cu/P39teiiQxo0aAAfH59yaetuRK/Xo0GDBjAYyj8FdEW7tkVFRZ7uQoWGhEdCcyw+j5SqhyAqDo899hjq1q1rs3pGTk4OVq1ahTFjxuDmzZsYOnQoGjZsCH9/f7Rv3x4///yz3XqlZuuzZ8+id+/e8PX1RVhYGOLj4232efvtt9GyZUv4+/ujadOm+OCDD1BcXAzArFH68MMPcfToUXAcB47jrH2WmjaPHz+OyMhI+Pn5oXbt2njxxReRk5Nj/d1iNpw9ezaCg4NRu3ZtxMTEWNtyhUuXLmHQoEEIDAxEtWrV8Oyzz+LatWvW348ePYp+/fohKCgI1apVQ+fOnXHo0CEAwMWLFxEdHY2aNWsiICAAbdu2xYYNG2Tb+ffff+Hv748VK1ZYt/3yyy/w8/PDyZMnHfbTcuwzZ85E/fr1UaNGDUybNg1GoxFvvvkmatWqhXvuuQdLliyx7iNntt6wYQNatmwJPz8/9OvXDykpKaJ2LBrAdevWoUWLFvD19cWAAQOQmpoqKjd//nw0a9YM3t7eaNWqFZYtWyb6XXhtLf1Ys2YN+vXrB39/f4SHh2Pv3r0AzKbz0aNHIzs723qPTJ06FQDw7bffWvtRv359PP300w7PFWB2xxg3bhwmTJiAOnXqYMCAAQCAEydOYODAgQgMDET9+vXx3HPPISMjw7rfr7/+ivbt21vvwaioKOTm5orqtnf/LVu2DF26dEFQUBAaNGiAYcOG4fr169bfLW4C69evR4cOHeDr64v7778fJ06cELWxe/du9OrVC35+fmjUqBFee+01m35oCQmPhOaQ0Zq462AMKMot/z8n1PsGgwEjRoxAbGwsmGC/VatWwWQyYejQoSgoKEDnzp2xfv16nDhxAi+++CKee+45HDhwQFUbPM/jySefhLe3N/bv348FCxbg7bfftikXFBSE2NhYnDx5El999RUWLVqEL7/8EgAwZMgQvPHGG2jbti3S09ORnp6OIUOG2NSRm5uLAQMGoGbNmjh48CBWrVqFrVu3Yty4caJy27dvx/nz57F9+3b8+OOPiI2NdXn5OZ7nMWjQIGRmZmLnzp2Ij4/HhQsXRP0bPnw47rnnHhw8eBCJiYl45513rMsXxsTEoLCwELt27cLx48fxySefIDAwULat1q1bY/bs2Xj11Vdx6dIlXL58GS+//DI++eQThIWFqervX3/9hbS0NOzatQtffPEFpkyZgsceeww1a9bE/v378fLLL+Oll16S1UYDQGpqKp588klER0cjKSkJY8eOxTvvvGNTLi8vDx999BGWLl2KhIQEZGVl4f/+7/+sv69duxbjx4/HG2+8gRMnTuCll17C6NGjsX37drv9f++99zBp0iQkJSWhZcuWGDp0KIxGI3r06IE5c+agWrVq1ntk0qRJOHToEF577TVMmzYNp0+fxqZNm9C7d29V5woAfvzxR3h7eyMhIQELFixAVlYWIiMj0bFjRxw6dAibNm3CtWvXrMsupqenY+jQoXj++edx6tQp7NixA08++aTo+XJ0/xUXF2P69Ok4evQo1q1bh5SUFIwaNcqmb2+++SY+//xzHDx4EHXr1kV0dLRVCD1//jwefvhhPPXUUzh27Bji4uKwe/dum2dBUxhxV5Kdnc0AsOzsbM3rXrDjHAt9+0/2+sojmtdNEJ4mPz+fnTx5kuXn55duLMxhbEq18v8rzHGq76dOnWIA2Pbt263bevXqxf7zn/8o7vPoo4+yN954w/q9T58+bPz48dbvoaGh7Msvv2SMMbZ582ZmMBjYlStXrL9v3LiRAWBr165VbOOzzz5jnTt3tn6fMmUKCw8PtyknrOe7775jNWvWZDk5pedg/fr1TKfTsatXrzLGGBs5ciQLDQ1lRqPRWuaZZ55hQ4YMUezLkiVLWPXq1WV/27JlC9Pr9ezSpUvWbf/88w8DwA4cOMAYYywoKIjFxsbK7t++fXs2depUxbblePTRR1mvXr1Y//792UMPPcR4nle1n+XYTSaTdVurVq1Yr169rN+NRiMLCAhgP//8M2OMseTkZAaAHTlyhDHG2LvvvsvCwsJE9b799tsMALt16xZjzHy+ALB9+/ZZy1jus/379zPGGOvRowd74YUXRPU888wz7JFHHrF+F15bSz++//576++W83zq1Clru9LrtHr1alatWjV2+/ZtVedISJ8+fVjHjh1F26ZPn84eeugh0bbU1FQGgJ0+fZolJiYyACwlJUW2Tlfuv4MHDzIA7M6dO4wxxrZv384AsJUrV1rL3Lx5k/n5+bG4uDjGGGNjxoxhL774oqiev//+m+l0OvE4VYLsGFaCWtmANI+E5lCqHoKomLRu3Ro9evTADz/8AAA4d+4c/v77b4wZMwYAYDKZMH36dLRv3x61atVCYGAgNm/ejEuXLqmq/9SpU2jUqBFCQkKs27p3725TLi4uDj179kSDBg0QGBiI999/X3UbwrbCw8MREBBg3dazZ0/wPI/Tp09bt7Vt2xZ6vd76PTg4WGQWdLbNRo0aoVGjRtZtYWFhqFGjBk6dOgUAmDhxIsaOHYuoqCh8/PHHOH/+vLXsa6+9hhkzZqBnz56YMmWKqgClH374AceOHcPhw4cRGxtrXcFLDW3btoVOVzrN169fH+3bt7d+1+v1qF27tuL5OHXqFLp16ybaJnc9DQYD7rvvPuv31q1bi87JqVOn0LNnT9E+PXv2tP6uhNAHNzg4GADsXrsHH3wQoaGhaNq0KZ577jn89NNPyMvLs9uGkM6dO4u+Hz16FNu3b0dgYKD1r3Xr1gDM2r7w8HD0798f7du3xzPPPINFixbh1q1bojoc3X+JiYmIjo5G48aNERQUhD59+gCAzfMgPO+1atVCq1atrOfv6NGjiI2NFfVzwIAB4HkeycnJqo/fGcrfK5a4ayCPR+Kuwcsf+F+aZ9p1kjFjxuC///0v5s2bhyVLlqBZs2bWCeuzzz7DV199hTlz5qB9+/YICAjAhAkTNA0e2Lt3L4YPH44PP/wQAwYMQPXq1bFy5Up8/vnnmrUhxGIytsBxHHieL5O2AHOk+LBhw7B+/Xps3LgRU6ZMwcqVK/HEE09g7NixGDBgANavX48tW7Zg1qxZ+Pzzz/Hf//5Xsb6jR48iNzcXOp0O6enpViFKDXLHXt7nwx2EfbUIzfb6GhQUhMOHD2PHjh3YsmULJk+ejKlTp+LgwYOqIrOFLyKA2R84Ojoan3zyiU3Z4OBg6PV6xMfHY8+ePdiyZQvmzp2L9957D/v378e9995rcwyW47Acg8X1YsCAAfjpp59Qt25dXLp0CQMGDHDqmcvJycFLL72E1157zea3xo0bq67HGUjzSGgOpeoh7jo4DvAOKP8/F9T8zz77LHQ6HVasWIGlS5fi+eeft07MCQkJGDRoEP7zn/8gPDwcTZs2xZkzZ1TX3aZNG6SmpiI9Pd26bd++faIye/bsQWhoKN577z106dIFLVq0wMWLF0VlvL29YTKZHLZlEawsJCQkQKfToVWrVqr77AyW4xMGg5w8eRJZWVkiP8SWLVvi9ddfx5YtW/Dkk0+KglIaNWqEl19+GWvWrMEbb7yBRYsWKbaXmZmJUaNG4b333sOoUaMwfPhw5Ofnl8mxydGmTRsbf1fp9QQAo9FoDQoCgNOnTyMrKwtt2rSx1pOQkCDaJyEhQbXvphxK94jBYEBUVBQ+/fRTHDt2DCkpKfjrr79caqNTp074559/0KRJEzRv3lz0ZxE0OY5Dz5498eGHH+LIkSPw9vbG2rVrVdX/77//4ubNm/j444/Rq1cvtG7dWlGzKjzvt27dwpkzZ6znt1OnTjh58qRNH5s3bw5vb2+Xjt0RJDwSZQajXD0EUeEIDAzEkCFD8O677yI9PV3knN+iRQurJuXUqVN46aWXRJHEjoiKikLLli0xcuRIHD16FH///Tfee+89UZkWLVrg0qVLWLlyJc6fP4+vv/7aZrJt0qQJkpOTkZSUhIyMDBQWFtq0NXz4cPj6+mLkyJE4ceIEtm/fjv/+97947rnnUL9+fedOigSTyYSkpCTR36lTpxAVFYX27dtj+PDhOHz4MA4cOIARI0agT58+6NKlC/Lz8zFu3Djs2LEDFy9eREJCAg4ePGid5CdMmIDNmzcjOTkZhw8fxvbt262/yfHyyy+jUaNGeP/99/HFF1/AZDJh0qRJbh2bM7z88ss4e/Ys3nzzTZw+fRorVqyQDTby8vLCf//7X+zfvx+JiYkYNWoU7r//fnTt2hWAOdgjNjYW8+fPx9mzZ/HFF19gzZo1bh1LkyZNkJOTg23btiEjIwN5eXn4888/8fXXXyMpKQkXL17E0qVLwfO8yy8TMTExyMzMxNChQ3Hw4EGcP38emzdvxujRo2EymbB//37MnDkThw4dwqVLl7BmzRrcuHHD7jUV0rhxY3h7e2Pu3Lm4cOECfv/9d0yfPl227LRp07Bt2zacOHECo0aNQp06dawJyN9++23s2bMH48aNQ1JSEs6ePYvffvutTANmSHgkNId8HgmiYjNmzBjcunULAwYMEPknvv/+++jUqRMGDBiAvn37okGDBk6tkKHT6bB27Vrk5+eja9euGDt2LD766CNRmccffxyvv/46xo0bh4iICOzZswcffPCBqMxTTz2Fhx9+GP369UPdunVl0wX5+/tj8+bNyMzMxH333Yenn34a/fv3xzfffOPcyZAhJycHHTt2FP1FR0eD4zj89ttvqFmzJnr37o2oqCg0bdoUcXFxAMw+hDdv3sSIESPQsmVLPPvssxg4cCA+/PBDAGahNCYmBm3atMHDDz+Mli1b4ttvv5Xtw9KlS7FhwwYsW7YMBoMBAQEBWL58ORYtWoSNGze6fYxqaNy4MVavXo1169YhPDwcCxYswMyZM23K+fv74+2338awYcPQs2dPBAYGWs8JAAwePBhfffUVZs+ejbZt22LhwoVYsmQJ+vbt63LfevTogZdffhlDhgxB3bp18emnn6JGjRpYs2YNIiMj0aZNGyxYsAA///wz2rZt61IbISEhSEhIgMlkwkMPPYT27dtjwoQJqFGjBnQ6HapVq4Zdu3bhkUceQcuWLfH+++/j888/V53s3JI6a9WqVQgLC8PHH3+M2bNny5b9+OOPMX78eHTu3BlXr17FH3/8YdUqdujQATt37sSZM2fQq1cvdOzYEZMnTxY921rDMVIP3ZXcvn0b1atXR3Z2NqpVq6Zp3d//fQEz1p/CoIgQfPV/HTWtmyA8TUFBAZKTk3HvvffC19fX090hCI8SGxuLCRMmaL5cIWFmx44d6NevH27duqXZijr2xjC1sgFpHokyg15LCIIgCKLqQcIjoTnOpJIgCIIgnEeYlkX69/fff3u6exWKS5cu2T1fzqaJIihVD1GGkOKRIAiibBAuISilYcOG5daPUaNGya6IUpEICQmxe77K0jfQXfr27Vshg09JeCQ0h/SOBEEQZUvz5s093YVKg8FgoPOlMWS2JsqMivi2RBAEQRCEe5DwSGgOuTwSdwP0ckQQRGVEi7GLhEdCcyyyI02tRFXEstyYM2vmEgRBVBQsY5d06URnIJ9Houwg6ZGoguj1etSoUcO6jJi/vz9lGCAIosLDGENeXh6uX7+OGjVqQK/Xu1wXCY+E5tBESlR1GjRoAACK69ASBEFUVGrUqGEdw1yFhEeizGCkeiSqKBzHITg4GPXq1UNxcbGnu0MQBKEKLy8vtzSOFkh4JDSHFI/E3YJer9dkICYIgqhMUMAMUWZQMCpBEARBVD1IeCQ0hxSPBEEQBFF1IeGR0J4SuzVpHgmCIAii6kHCI1FmUMAMQRAEQVQ9SHgkNIfM1gRBEARRdSHhkSgzyGxNEARBEFUPEh4JzaFUPQRBEARRdSHhkSgzSPFIEARBEFUPEh4JzeHI65EgCIIgqiwkPBKaYzFbk88jQRAEQVQ9SHgkyhCSHgmCIAiiqkHCYxUgNTUVffv2RVhYGDp06IBVq1Z5tD9ktCYIgiCIqovB0x0g3MdgMGDOnDmIiIjA1atX0blzZzzyyCMICAjwaL/IbE0QBEEQVQ8SHqsAwcHBCA4OBgA0aNAAderUQWZmpseER0rVQxAEQRBVlwpltv7444/BcRwmTJhgt9ydO3cwYcIEhIaGws/PDz169MDBgwdFZZo0aQKO42z+YmJiAABTp061+a1169aaH9OuXbsQHR2NkJAQcByHdevWyZabN28emjRpAl9fX3Tr1g0HDhxwqb3ExESYTCY0atTIjV67hyXamhSPBEEQBFH1qDDC48GDB7Fw4UJ06NDBYdmxY8ciPj4ey5Ytw/Hjx/HQQw8hKioKV65cEdWXnp5u/YuPjwcAPPPMM9Yybdu2FZXZvXu33XYTEhJQXFxss/3kyZO4du2a7D65ubkIDw/HvHnzFOuNi4vDxIkTMWXKFBw+fBjh4eEYMGAArl+/bi0TERGBdu3a2fylpaVZy2RmZmLEiBH47rvv7B4HQRAEQRCEy7AKwJ07d1iLFi1YfHw869OnDxs/frxi2by8PKbX69mff/4p2t6pUyf23nvvKe43fvx41qxZM8bzPGOMsSlTprDw8HDVfTSZTCw8PJw9/fTTzGg0Wrf/+++/rH79+uyTTz5xWAcAtnbtWpvtXbt2ZTExMaK2QkJC2KxZs1T3r6CggPXq1YstXbpUVfns7GwGgGVnZ6tuQy1xBy+x0Lf/ZKN+2K953QRBEARBlA1qZYMKoXmMiYnBo48+iqioKIdljUYjTCYTfH19Rdv9/PwUNYdFRUVYvnw5nn/+eXACh7yzZ88iJCQETZs2xfDhw3Hp0iXFdnU6HTZs2IAjR45gxIgR4Hke58+fR2RkJAYPHoy33npL5dHa9i0xMVF07DqdDlFRUdi7d6+qOhhjGDVqFCIjI/Hcc8/ZLTtv3jyEhYXhvvvuc6m/zkBma4IgCIKoenhceFy5ciUOHz6MWbNmqSofFBSE7t27Y/r06UhLS4PJZMLy5cuxd+9epKeny+6zbt06ZGVlYdSoUdZt3bp1Q2xsLDZt2oT58+cjOTkZvXr1wp07dxTbDgkJwV9//YXdu3dj2LBhiIyMRFRUFObPn+/UMQvJyMiAyWRC/fr1Rdvr16+Pq1evqqojISEBcXFxWLduHSIiIhAREYHjx4/Llo2JicHJkydtfES1hOJlCIIgCKLq4tFo69TUVIwfPx7x8fE2mkR7LFu2DM8//zwaNmwIvV6PTp06YejQoUhMTJQtv3jxYgwcOBAhISHWbQMHDrR+7tChA7p164bQ0FD88ssvGDNmjGLbjRs3xrJly9CnTx80bdoUixcvFmkzPcEDDzwAnuc92gc5KFUPQRAEQVQ9PKp5TExMxPXr19GpUycYDAYYDAbs3LkTX3/9NQwGA0wmk+x+zZo1w86dO5GTk4PU1FQcOHAAxcXFaNq0qU3ZixcvYuvWrRg7dqzdvtSoUQMtW7bEuXPn7Ja7du0aXnzxRURHRyMvLw+vv/66+gOWoU6dOtDr9TYBN9euXUODBg3cqttTeFqYJgiCIAii7PCo8Ni/f38cP34cSUlJ1r8uXbpg+PDhSEpKgl6vt7t/QEAAgoODcevWLWzevBmDBg2yKbNkyRLUq1cPjz76qN26cnJycP78eWu+RDkyMjLQv39/tGnTBmvWrMG2bdsQFxeHSZMmqTtgGby9vdG5c2ds27bNuo3neWzbtg3du3d3uV5PYhEdSfFIEARBEFUPj5qtg4KC0K5dO9G2gIAA1K5d27r9m2++wdq1a0XC1ebNm8EYQ6tWrXDu3Dm8+eabaN26NUaPHi2qi+d5LFmyBCNHjoTBID7USZMmITo6GqGhoUhLS8OUKVOg1+sxdOhQ2b7yPI+BAwciNDQUcXFxMBgMCAsLQ3x8PCIjI9GwYUNZLWROTo5Im5mcnIykpCTUqlULjRs3BgBMnDgRI0eORJcuXdC1a1fMmTMHubm5NsdDEARBEAThaSr8CjMZGRk4f/68aFt2djbeffddXL58GbVq1cJTTz2Fjz76CF5eXqJyW7duxaVLl/D888/b1Hv58mUMHToUN2/eRN26dfHAAw9g3759qFu3rmw/dDodZs6ciV69esHb29u6PTw8HFu3blXc79ChQ+jXr5/1+8SJEwEAI0eORGxsLABgyJAhuHHjBiZPnoyrV68iIiICmzZtsgmiqSxYrNaMnB4JgiAIosrBMZrh70pu376N6tWrIzs7G9WqVdO07jWHL2PiL0fRq0UdLBvTTdO6CYIgCIIoG9TKBh5P1UNUPShehiAIgiCqLiQ8EmUG6bQJgiAIoupBwiOhORylCScIgiCIKgsJj4TmWANmKFkPQRAEQVQ5SHgkCIIgCIIgVEPCI1FmkM8jQRAEQVQ9SHgkygwSHgmCIAii6kHCI6E5tLY1QRAEQVRdSHgkygwKmCEIgiCIqgcJj4TmkN6RIAiCIKouJDwSmlO6trVn+0EQBEEQhPaQ8EgQBEEQBEGohoRHQnMsK8yQ4pEgCIIgqh4kPBJlB0mPBEEQBFHlIOGR0BzK1EMQBEEQVRcSHokyg1L1EARBEETVg4RHQnNI8UgQBEEQVRcSHgnNoVQ9BEEQBFF1IeGRIAiCIAiCUA0Jj0QZQKl6CIIgCKKqQsIjUWYwslsTBEEQRJWDhEdCcyhVD0EQBEFUXUh4JMoM0jsSBEEQRNWDhEdCc0jxSBAEQRBVFxIeCc3hSuzW5PJIEARBEFUPEh4JgiAIgiAI1ZDwSGiOxWxNikeCIAiCqHqQ8EiUHWS3JgiCIIgqBwmPhOZQqh6CIAiCqLqQ8EiUGaR3JAiCIIiqBwmPhOaQ5pEgCIIgqi4kPBKaw4FS9RAEQRBEVYWER4IgCIIgCEI1JDwS2lNitmbk9UgQBEEQVQ4SHokyg8zWBEEQBFH1IOGR0ByKlyEIgiCIqgsJj0SZQZpHgiAIgqh6kPBIaA5HuXoIgiAIospCwiOhObS2NUEQBEFUXUh4JAiCIAiCIFRDwiOhORarNSOnR4IgCIKocpDwSBAEQRAEQaiGhEdCczhK1kMQBEEQVRYSHgnNKTVbe7YfBEEQBEFoDwmPBEEQBEEQhGpIeCQ0pzRVD6keCYIgCKKqQcIjQRAEQRAEoRoSHgntIZ9HgiAIgqiykPBIlBkkOxIEQRBE1YOER0JzKFUPQRAEQVRdSHgkNIdWmCEIgiCIqgsJjwRBEARBEIRqSHgkNKc0VQ9BEARBEFUNEh4rOampqejbty/CwsLQoUMHrFq1ytNdujtJ/htYORy4nebpnhAEQRBEmWLwdAcI9zAYDJgzZw4iIiJw9epVdO7cGY888ggCAgI81ifO6vTosS6UPz8+Zv7fWAD8Z7Vn+0IQBEEQZQgJj5Wc4OBgBAcHAwAaNGiAOnXqIDMz06PCo4W7SXa0kn3Z0z0gCIIgiDKlUpmtP/74Y3AchwkTJtgtd+fOHUyYMAGhoaHw8/NDjx49cPDgQVGZqVOnguM40V/r1q017e+uXbsQHR2NkJAQcByHdevWyZabN28emjRpAl9fX3Tr1g0HDhxwqb3ExESYTCY0atTIjV67D0eZegiCIAiiylJphMeDBw9i4cKF6NChg8OyY8eORXx8PJYtW4bjx4/joYceQlRUFK5cuSIq17ZtW6Snp1v/du/erVhnQkICiouLbbafPHkS165dk90nNzcX4eHhmDdvnmK9cXFxmDhxIqZMmYLDhw8jPDwcAwYMwPXr161lIiIi0K5dO5u/tLRS/7rMzEyMGDEC3333nWJb5YU1YIZS9RAEQRBElaNSCI85OTkYPnw4Fi1ahJo1a9otm5+fj9WrV+PTTz9F79690bx5c0ydOhXNmzfH/PnzRWUNBgMaNGhg/atTp45snTzPIyYmBsOGDYPJZLJuP336NCIjI/Hjjz/K7jdw4EDMmDEDTzzxhGJ/v/jiC7zwwgsYPXo0wsLCsGDBAvj7++OHH36wlklKSsKJEyds/kJCQgAAhYWFGDx4MN555x306NHD7vkhCIIgCIJwh0ohPMbExODRRx9FVFSUw7JGoxEmkwm+vr6i7X5+fjaaxbNnzyIkJARNmzbF8OHDcenSJdk6dTodNmzYgCNHjmDEiBHgeR7nz59HZGQkBg8ejLfeesul4yoqKkJiYqLouHQ6HaKiorB3715VdTDGMGrUKERGRuK5555zqR9aczfGyxAEQRDE3UKFFx5XrlyJw4cPY9asWarKBwUFoXv37pg+fTrS0tJgMpmwfPly7N27F+np6dZy3bp1Q2xsLDZt2oT58+cjOTkZvXr1wp07d2TrDQkJwV9//YXdu3dj2LBhiIyMRFRUlI020xkyMjJgMplQv3590fb69evj6tWrqupISEhAXFwc1q1bh4iICEREROD48eOK5efNm4ewsDDcd999LvebIAiCIIi7lwodbZ2amorx48cjPj7eRpNoj2XLluH5559Hw4YNodfr0alTJwwdOhSJiYnWMgMHDrR+7tChA7p164bQ0FD88ssvGDNmjGy9jRs3xrJly9CnTx80bdoUixcvLk1L4yEeeOAB8DyvunxMTAxiYmJw+/ZtVK9evYx6ZT4n5PJIEARBEFWPCq15TExMxPXr19GpUycYDAYYDAbs3LkTX3/9NQwGg8j/UEizZs2wc+dO5OTkIDU1FQcOHEBxcTGaNm2q2FaNGjXQsmVLnDt3TrHMtWvX8OKLLyI6Ohp5eXl4/fXX3Tq+OnXqQK/X2wTcXLt2DQ0aNHCr7ooAI8M1QRAEQVQ5KrTw2L9/fxw/fhxJSUnWvy5dumD48OFISkqCXq+3u39AQACCg4Nx69YtbN68GYMGDVIsm5OTg/Pnz1tzJkrJyMhA//790aZNG6xZswbbtm1DXFwcJk2a5PLxeXt7o3Pnzti2bZt1G8/z2LZtG7p37+5yvZ6GUvUQBEEQRNWlQputg4KC0K5dO9G2gIAA1K5d27r9m2++wdq1a0UC2ObNm8EYQ6tWrXDu3Dm8+eabaN26NUaPHm0tM2nSJERHRyM0NBRpaWmYMmUK9Ho9hg4datMPnucxcOBAhIaGIi4uDgaDAWFhYYiPj0dkZCQaNmwoq4XMyckRaTKTk5ORlJSEWrVqoXHjxgCAiRMnYuTIkejSpQu6du2KOXPmIDc3V9TXykZpqh6PdoMgCIIgiDKgQguPasjIyMD58+dF27Kzs/Huu+/i8uXLqFWrFp566il89NFH8PLyspa5fPkyhg4dips3b6Ju3bp44IEHsG/fPtStW9emDZ1Oh5kzZ6JXr17w9va2bg8PD8fWrVtl9wGAQ4cOoV+/ftbvEydOBACMHDkSsbGxAIAhQ4bgxo0bmDx5Mq5evYqIiAhs2rTJJoiGIAiCIAiiIsAxyuR8V2IJmMnOzka1atU0rTspNQuD5yWgYQ0/JLwTqWndFZapJcFHdVsDMfs92xeCIAiCcAG1skGF9nkkCIIgCIIgKhYkPBKac3fHy9zdR08QBEFUfUh4JMqMu9Mj4m48ZoIgCOJugoRHQnMoVQ9BEARBVF1IeCQ0h7OsMOPhfhAEQRAEoT0kPBIEQRAEQRCqIeGR0ByL2fqudHmkgBmCIAiiikPCI0Foyl0pMRMEQRB3ESQ8EmUGI0GKIAiCIKocJDwSZcbdabYmCIIgiKoNCY+E5tzdqXru6oMnCIIg7gJIeCQ0h1L1EARBEETVhYRHgtAUEpkJgiCIqg0Jj4Tm3N2pegiCIAiiakPCI0EQBEEQBKEaEh4JzSkNmLkbVY8UMFOpybkBmIye7gVBEESFhoRHoswgszVRqbh6HJjdHIh91NM9IQiCqNCQ8EhoDkfat8pFQbane1AxOLLc/H/qPs/2gyAIooJDwiOhOdaAGc92w0NUsqPe9RnwcWPg2C+e7glBEARRSSDhkSDuZv6aYf7/j/Ge7UdFgPwsCIIgVEHCI6E5FqM1uysn47vEZJ+fZRY8b5zxdE8IgiCIcoaER4IgnGfDm2aT97f3e7onBEEQRDlDwiOhOXe3z2NlxUmNaep+8//MpH1XPAbdsQRBEGog4ZEoM+5Kq/VdI4DcLcdJEARBSCHhkSgD7hK/v6oER9eMIAiCUAcJj4TmlK5tfTdqp0gIq7TclfcrQRCE85DwSBAEQRAEQaiGhEdCc6ypejzaC8I5nNSY0sUlCIK4ayHhkSAIAgBJxESZsP874JeRgKnY0z0hCM0weLoDRNWDo1w9lQ+nA2bo4hKEKja+af6/1SNA+BDP9oUgNII0j4TmUMgIQRCEhMLbnu4BQWgGCY9EmUG6qSpMVYxMrorHRFQc6P4iqhAkPBKac3en6qmskL6YIMoWGg+JqgMJjwRBuABNhAThFPQyTVQhSHgkNIcr0WLRUFmJIMUj6I4lyhTGe7oHBKEZJDwSBOE8pEUhCCehZ4aoOpDwSGhOqc+jZ/tBEARRYaABkahCkPBIEASct1tX8Ylw6SDg8iFP94KoUlTxZ4a4qyDhkSgzGA2WRGVCqBm6sAP4vr979eVnkbaJKIXuBaIKQcIjoTlktq6EOLvCDF1c+1zYAXwSCqyf6OmeEBUGemaIqgMJjwRBEFrz1wzz/4d+8Gw/iIoDRVsTVQgSHgnNsaxtTe/ZVRknru6lfcDOTwGTsey6owka3rF8RT9WotwhbT1RhTB4ugMEQXiAi3uAvEzBhjJM9PjDAPP/fjWBri+UXTsVCd7k6R4QFQ4SHomqAwmPhOZYxRAaKysuSwa6t78rWpSb59xrszJBJkpCCmkeiSoEma0JzXE29qJKUVkPvlz6XcHPjZaTO2keCRtIeCSqDiQ8EmVGhUnVw1j5vfWTdkGZyipYuwIj4ZGQQGMDUYUg4ZHQHOva1hVhrOR5YPFDwI/RFaRDxF0BaR4JKTT+EFUI8nkkqja3LwOXD5g/F94BfKt5tj8VFlphhqKtibKlKj4zxN0KaR4JzbEmCfdsN2wpD7Pp3WSadZq76NxQwEzlxVQMHFkOZF3Stl7SPBJVCBIeCYKgFWa0hszWlZc9c4HfYoCvO2lcMT0zRNWBhEdCcyxiCLsbBYy78ZjVUtG1slpeu8ocMHNkObCwN3A7zdM98QzJO83/88Xa1uvq/WUsNK+TThAVCBIeCe2pSDKC3IDNGHB+O5B7s/z7UxHQREgiIdkulVnz+FsMkH4U2Pyep3tStXDVlWFOB/M66aKk/gThWUh4JMqMCiteHPsFWDYYmNfV0z3xDLLCY0WS+KsAUs2jyWgWxs5str9f+lFg/0JzlgBPU5Tj6R5UfkTPmosjYs5V8/+p+93uDkFoBQmPhOZUqFQ9QiwdOr3e/H9ehvZtVHTTLABNxHpXLm6FPzdlmCT86Apg7zfAimft77ewN7DxLeDoz9r1RY7MC461oxXuAa6ECM+hu+eTrgdRgSDhsQqQmpqKvn37IiwsDB06dMCqVas83aWKg1BgoQhYM3KTEK0woy1SwSz7snP7XzuhXV+kHI0Dvu4IrBppvxw9L+4jOofuCn8kPBIVBxIeqwAGgwFz5szByZMnsWXLFkyYMAG5ubke64+NHHI7HVg8wGwuLm9kzUZlKMRUCu0A+TyWORU5YCZhjvn/U384KEjX2H001DwSRAWCkoRXAYKDgxEcHAwAaNCgAerUqYPMzEwEBAR4uGclbHkfSN1n/uvgwGxXltDgbcZTGqUKb7bWkMocMGPhrn1eNLxPRWZrN5+7u/Z6EBWRCqV5/Pjjj8FxHCZMmGC33J07dzBhwgSEhobCz88PPXr0wMGDB62/z5o1C/fddx+CgoJQr149DB48GKdPnxbVMXXqVHAcJ/pr3bq15se0a9cuREdHIyQkBBzHYd26dbLl5s2bhyZNmsDX1xfdunXDgQMHXGovMTERJpMJjRo1cqPX7iEcehljQEG2x/oiy90kxMihRcAMTWT2kWoenT1fFeL8VoQ+VHI0NVsTRMWhwgiPBw8exMKFC9GhQweHZceOHYv4+HgsW7YMx48fx0MPPYSoqChcuXIFALBz507ExMRg3759iI+PR3FxMR566CEbU27btm2Rnp5u/du9e7fddhMSElBcbJv76+TJk7h27ZrsPrm5uQgPD8e8efMU642Li8PEiRMxZcoUHD58GOHh4RgwYACuX79uLRMREYF27drZ/KWlleZiy8zMxIgRI/Ddd9/ZPY6yhquowll5TMgV9dhF0CRW5lRkf0G1z0GFEGArO1qarel6VBku7gHObfN0L9yiQpitc3JyMHz4cCxatAgzZsywWzY/Px+rV6/Gb7/9ht69ewMwaxH/+OMPzJ8/HzNmzMCmTZtE+8TGxqJevXpITEy07gOYfQUbNGigqo88zyMmJgYtWrTAypUrodfrAQCnT59GZGQkJk6ciLfeestmv4EDB2LgwIF26/7iiy/wwgsvYPTo0QCABQsWYP369fjhhx/wzjvvAACSkpLs1lFYWIjBgwfjnXfeQY8ePVQdU3nAmKfDJMrZ57EyoEnAjCsTWQU/7zQ3i3MJVmQBuLKgaeJ5ukGrBDwPLCmRCd48DwTU8Wx/XKRCaB5jYmLw6KOPIioqymFZo9EIk8kEX19f0XY/Pz9FzWF2ttlsWqtWLdH2s2fPIiQkBE2bNsXw4cNx6ZLyWqY6nQ4bNmzAkSNHMGLECPA8j/PnzyMyMhKDBw+WFRzVUFRUhMTERNGx63Q6REVFYe/evarqYIxh1KhRiIyMxHPPPWe37Lx58xAWFob77rvPpf6qQWS2LrNWXKC8B98Ta4C/vyjfNlXhoauilVbWVGxOabPmRW3qqyrkZbqXSPrQEuDTe7XrDyEWwEkYJwCAN5Z+vnPVc/1wE48LjytXrsThw4cxa9YsVeWDgoLQvXt3TJ8+HWlpaTCZTFi+fDn27t2L9PR0m/I8z2PChAno2bMn2rVrZ93erVs3xMbGYtOmTZg/fz6Sk5PRq1cv3LlzR7HtkJAQ/PXXX9i9ezeGDRuGyMhIREVFYf78+c4feAkZGRkwmUyoX7++aHv9+vVx9aq6GyshIQFxcXFYt24dIiIiEBERgePHj8uWjYmJwcmTJ0U+olUaOYd1JSGGMeDKYfNyYFrw62hg24dA2hFt6tMKLYRoT74VpOw2J9M+FufBTlQwTMVmwe/Te82fXeHPCeLvFUHY4Xng5G9AlvKLfcWGzNaEBKHwaNJorvEAHjVbp6amYvz48YiPj7fRJNpj2bJleP7559GwYUPo9Xp06tQJQ4cORWJiok3ZmJgYnDhxwkYrKTQld+jQAd26dUNoaCh++eUXjBkzRrHtxo0bY9myZejTpw+aNm2KxYsXe9zH74EHHgBfEVakKEGUWpExD/sBOrHCw/6FwKa3geZRwH9Wa9eFCrcuradWmNGojTJLg1OJJ2dhUFp+FhBY12Nd0ZQTq4E1Y82fpzoReHfrIhAUDBi8y6ZfaqGAmapHUR6g9wb0LopPQuHRWKRNnzyARzWPiYmJuH79Ojp16gSDwQCDwYCdO3fi66+/hsFggMkkP0k0a9YMO3fuRE5ODlJTU3HgwAEUFxejadOmonLjxo3Dn3/+ie3bt+Oee+6x25caNWqgZcuWOHfunN1y165dw4svvojo6Gjk5eXh9ddfd+6gJdSpUwd6vd4m4ObatWuq/TEJO8iu8KAgxBxYaP7/3FZt+6D30rY+d/HU2tZavUTQHCyDM84ilShgJmWXC/skAF91ABY/qH1/7MGbgN//CyT+WLqNVpipWhTeAWYGA992c70O4cuvscD9PnkIjwqP/fv3x/Hjx5GUlGT969KlC4YPH46kpCRrUIoSAQEBCA4Oxq1bt7B582YMGjQIgFnbNW7cOKxduxZ//fUX7r3XsR9PTk4Ozp8/b82XKEdGRgb69++PNm3aYM2aNdi2bRvi4uIwadIk5w5cgLe3Nzp37oxt20ojr3iex7Zt29C9e3eX6/UknGAiYyVbPIZTa8tq2E9hnj9dhYhLK0XOHFkposTdx2jiUVBcGXIwOikoiNX9GnWhIlgzXLgvk34y/5+epGlPHHJ6A3B4KfDHa4KNGqxtTVQcUktS6N20r2Syi3Bu0MpFygN4dFYLCgoS+SECZoGwdu3a1u3ffPMN1q5dKxKuNm/eDMYYWrVqhXPnzuHNN99E69atrdHKMTExWLFiBX777TcEBQVZfQerV68OPz8/AMCkSZMQHR2N0NBQpKWlYcqUKdDr9Rg6dKhsX3mex8CBAxEaGoq4uDgYDAaEhYUhPj4ekZGRaNiwoawWMicnR6TNTE5ORlJSEmrVqoXGjRsDACZOnIiRI0eiS5cu6Nq1K+bMmYPc3Fzr8VQ6KpQcIvPmryQoaSlAmQTmCJ0HNY95mcDSQUD7Z4CelknNU5OYVufX9f4PmLMLlzLzcHTKQ/D3rmBCvWZodX0rgLBTmV5q8m/ZbtNS81gRrsddjwbXQGi2Ls5zvz4PUeFHz4yMDJw/f160LTs7G++++y4uX76MWrVq4amnnsJHH30ELy/zJG0JYOnbt69ovyVLlmDUqFEAgMuXL2Po0KG4efMm6tatiwceeAD79u1D3bryvkI6nQ4zZ85Er1694O1d6kcTHh6OrVu3Ku536NAh9OvXz/p94sSJAICRI0ciNjYWADBkyBDcuHEDkydPxtWrVxEREYFNmzbZBNFURjxuadFa83jnGnD8FyBiOOBfS7mcUHh01TdGC/bMBa4eM/9ZhEePXxQ3cUMjdv6GOdfrscvZuL9pbUm9Fem8OCk0lYnmsSKdj/LEieO+dhI4Fw90e1mhKg01j3ft9ahAaHEJhJpHEh61Y8eOHaLvU6dOxdSpU0Xbnn32WTz7rPIyd0zFQ7Zy5Uqn+/bgg/I+NB07dlTcp2/fvqr6M27cOIwbN87pPlVERPMYPBQwczsN2PgW0LRUcHfo86imnz89BVw9Dpz/C3hurXI5YcSrJ83WJrUO2ZV0hZkfBgJdxwLtnnJt/8QfgdMbgad/0LZfHuUuN1uX5705v8S1yFhoDtCx7Yzgo7vnsxyOa/eXwMEfgDGbgWohZd9epUNjzWNR5RUePZ6qhyDKhN9fA079AayfWLpNi8nwakkKpPN/2S+nWmjzAJ4S/DQLmBH0/9Ie4Nfnne+K5cMfrwFnNgKHFmvSNe1wYzlDR9dX9fWvAC8IHjFbu9CmUjouLfM8lsdzu3UqkH0J+Oujsm+rMqLFNRCZrXOVy1VwSHgkNEe8trV0SzkhmxfOgc+jvX5e3Asc/1V9+0Lh0ZNaOtljVdGfgttA8t/mPHuyeHKFmTI4nwW3y6Zej3CXma0LbpdcP09iJ3es9bMLwqOnroFQwLmLuZVbhFPpwntLixy5gvugqPIKjxXObE0QmsDJvBc5GojtaTmWPOxc+0KztUfNfzLHpGZCWjIQuHYCeGQ20PUF7bvlDi5OqHbdRypTYIYczmgeVR9rRRAeHfTVZAQ+bmT+/EGG59JicZz8eRU++67k4i1P4THhq/Jrq5Jw30dbYeQZ1r/2ANqGVNde80hma4IoxdNJ00s6IbNRxufxwCLhTtq1LzJbuzDgZKUCOz4BcjPc64ejCU2JayfM/x/7Rf53VwZRZ+6Lm+fNyzvKtuOq8OjSbpWEMkgJUxFOmKNAoEKBVijvpqVgmXbJOYRCfUmgROEd4HKiyvOrZbS2A+Iny7d7F2Pkzech4ZxlHNbgepDZmiDksRERBBPAuet30Pez7fg18XJ590L+Yd8gyNFZVql6XBlkYh8FdswE1rir9VNptlZcslFLrakT53duJ/Pyjqd+t/3NxUGbF+xn84LD6bSZnPfNB74WBtCV04uUyLfOCZ/HTf9TV2dF4ONQ4NSfdgpUgJdWKXJm6+/6Ad9HAifXKe93K8W8DGdFEOCJUrRIvSSMtibNI0HII32+3vz1GFJu5mHSqqNl27A9QdBZIdGVQUK0vrArmseL5v8v7HR+XyGumO/FhZ3c7k5bMlza73rbEni7u2kkeGx6B8i8UPpdZ1nooIyFALW+dWc2AxmnS7/vm2evUre7pSmF2UDccDsFPN1fR2brEqHh5lnz//Z8qL8KN79AXhWOk54+vruX0sdLAw0/TyvMEIQsNql6BOQXldPqHrLmWhfzPIoEQZVUuoAZFQ7/riCcPF3R7Gq4jrVY8yj5saxcLTj7q2QBAIq1mEBUCo8rlFOc2VZZEYQVB9elIrjIAHb6Yee6qNHsXjnscpcI7ZB9ElzVzIuCkSrCM+YaJDwS5QpfbhOSPS2Ak3keXUm7467PowW3J0cXA2ZKCytsVqt5FA6wLhyLXNSnywEz9n7lUCYDuc6B8Hj1OPBRfWDj2+Ltzh6jpiuZVCAc3f8V5ljVRFtLXoScFT7K81grzHktY9x6zlwUHoX3QSU+zyQ8EpojWttakqqn/GRHF1PUyOGS8CiMtq4MmkcFPJ2bjpfTPDpRJ89b+2CyG23tXLdU40jzuONj8//7F7jZkJbJqC31VLaJzYNaSDXR1q5oHsU7ON0twg77FgBftAEyzqrfR4u8ncIX4kr3jJVCwiNRrnhW8+ggz6Oi5rESm63Vah4VrW5u5nl0W/iUER7V1mkyAt92A2IfA+Do3isjwUPnYIhV0ky645fr7DlXSnhfIQJmHGkehX2siBOxoE/SVD0V4vwqURHPpcZsehu4k272U3aAfNIHDaKtK/Q9YB8SHgnNEfs8itFySCooNqHYpPDwyQWKuLq2tQfN1gxAcoYb6Ryc1DxeuJGDkT8cUFNUHe76PLqSG8/C9X+AjDPAxd22XZGW5biyEfJl70MBmi1d6YbwuOwJoDjffp2uwBhw47RZiHcVh2ZrJ6LMyxQXkoRXJLN1JdaAuY2sdUNMqe++Bhp+XgPtZQWAhEei7OHEZut6uAUO7j00BcUmtJuyGb0+2a7Qpr0oY8lA70hA8aDZ2sQz9Ju9A0mpWYplfjmYijlbz8j/KHse5I7XfE5e/ekwdp654aAsnDgmd83W2vk8ekTz6Agl4bG8fbGMhe73QcrhH4F5XYFVI92rxx5loXl05SWH4+BQy++Kz2N5CXV3s/Do6AVPiBY+jxQwQxCOka7q0bN4Lw74xmC2l3s+Xmeu3YGRZ7h6WyFS1RmNm2VQLyuztRsDhCW9zJZ/riqWeWv1MczZehYnrmTL/OpcwMzlW1INlIbR1q4IaLLR1i70ibFydJlwgoqgeQRcTyZvD8uKJf/ay83oCGc0jyWfK9R1Fpqt3QyYKUtBw0YrWs7nMDPZc0v1OfWyoLHwKK0jP6vS5H4k4ZHQHHtm65FFKwEAT+l3a9ae/LJz9nwepdu11DxytvtoMBAbdI4HuOx8GSHXSbO1TWnGgOwrwD9rJZOfyuheu7ZiFbileRTeiLwoz6NNDZxObqtjGDOvAZ5zw3FZORxFYzvTD+tnVyY19wPMjl/ORmqmYOJzRqOjhFNmaw8vAyq3Go7dgBk3tMuO2PEJ8Ovz6t0+PHnurh4Hvo4Avulaps2cTLuNNYcvy8wXjgcm6y6ifVVej+IC84pZFpSEx8Ic4JPQ0uU2Kzi0tjVRrmhlHBQ+wzwD9Gry9ikNkFahSAvNI7Pdx42BmZX0Se8o8AJKZlm1ATN28tR9HWEWhh+fC3QaIVOEV44qLpNoaxeQaB55acZwV1Mind1izp1o8APel9MOO6hXJ1iL2a1zVRaaR/X9uXwrD9HfmF8IUz5+1FKp8/2w7Zj9n7UwI5YFjNn60bqbqscZdsw0/99pJNC0j+PyNn0pR83jyZJVpG6X7apjj3z9NwCgZoA3+rWqV/qDy5pHFeeoKBf45j7g9hXg+c1A4/vF94HwvFuS98u9MFdASPNIaI5tqh7hbwoDZlqSedmu5F1Ot2eSWzrEbsCMZLCwPMAVMc9jCQYb6dgWednRzQmc8aXHkiLQFqvNK+i22VrmflEr1HBSzaN5v3u5dNQ+t1qilXFDeAQAo1zAiQqEZmt3hEd3A0fcXEP87PUc241aaB4dUVECZmyeM7kAC0n/VL0YOa/p2mNdhxlAkcx1kW3Gg4I374JbkBv8m35HssWJZ9/Oy0p+kQn7LtwUz0fnt5sFRwDIumT+n6c8jwQhi73VOzilAXD5U0DaYeDHaKfbc0vjBgjeBMtIeHRrgDD3SY3ZWvY8qNYomcvZ/CIs6+Un37C9iUe4v7QvybuAA4uU9wXcz/Mo2Mcypm/3eQPN97wJJP0k7psnollFwqMbE7jbGjiZ/jlxPrz1MlOJFqu/uGS29sSErPBCKrc8obSMxgz7XrCkp+qxy4NCjCs+5SpgjNlaGODa6lJWU7edl+YXlh7C/323D/N3nCvdyMtYoChVD0GoQO2YlJfhuIwChUYeF29KnK3t+fpJf+PLImDGdm3rNYcv46Vlh5BX5LxZQq8gPAr9d+RPtWA/3oXJVTi4eQUoFbJXgfJPP0YDGyaJNZoAkHuz9LNbJhyJ5lE6kaTuc6NumTZkf3Zkthaa+12YwK+dBK4kire5MiHJCYpO1CN8uTFa02eVQwR7RdU8ygXveCJVj9o0SR7VPJaNmXbUkoN45Ou/BfejGds0Xc5EWyuYnAHsLtH4Lt93SVBGRthU0DyeTL+tvh8VABIeCc2xnTJkHMndRFjL0O/2oc9nO7D93+t2e6GseVQwZ1vQKGBm4i9Hsfmfa1i696Lq2iw985LT7ACiIBDRSck4BxTclphuTaL+yGF7BgRlvf0VOmlP86hiUsq6JP7+WVPB/nJJwl0zy9rsJtKKlvFQqCREKmoeVR7j/O7AokggTyBwa6V5dEKY9TKUnr9CowM3EC1xJYChTJCk6imNsBBsU9Y8ZucX48v4M0g9uRf4c6JCGy4cn1qTsCejrctI87jzzA38e/WOjVBme1uWbLhzDdj7LZB/C4D4xdwKryw8yiPz8iCTqmfnmRt4Z/VxFfVVHEh4JMoUJhnwFM3WztYr88b2036BEGI3yliqJXDge+SK2VopMhlAToF2mkdREIjl87V/gG86A1+2g1jzaBEeZQY9pYle0Wyt1udRjTnVjpAhZ7a2N2ibjMD1f2X6xGyXJxR951A2wgdn25bws7Nm61spwPpJ5tQmwnqyBcEGmmkenRAeBQFdRUZPaR4rkAlQxmydlVuIQymZtmUAfPjHP/hq21k0+uVh4NBiQRk370m1glkV9nk0FGSLzgMnvS8tY9/yp4DN7wJrXgKg8Mg6e7/JjX8yZuu/Tl0Tz432FB3HVgHXTzluu4wh4ZHQHE6SFFyIrgy1AyL5StbXT2FHTc3WchoHHtjyPr7w+hYAg6+X+sfOEm2tU+ibWHgs+XA23vx/YbZN0IhN3xxhFOTRVDJbq9U8uuSq6OSktuYF85KEB79XDJiRrbusfR5F7SoIj8JJ5cB3QJ5A0LCw/Cng4CJg2WBlwbzkc3ZeMS7dLJ+cccJTranmsdKk6pFi6yN36eYdjF16SFCktL+JF2+pqFIbzSNjzPyCGT/FnFfQ1bq1wp0ViBSwKBca4CbClncAFvRyvNO1Es3f2c0AxGOr9RNTVgoodMS2vMw9a//FVsDZLcCascC39ztuu4wh4ZEoZ7Q3W1sQC1h2UvUo+ScJ9ynMAQ4tMefvc0XzKJ3Y98zFk/rdaMalwdvg/GP3v7XHxVoLuWaseSwFxyE0x9o1WysEzBQKIhO9fOUbtndNnTHFZl4Ajvwk3ibrD2Wnnn/WmP//+wvJLszWDOWx9CRC4VHg8yh9SfljvO2uN0uc8W+liPsvo80In7YFvT/bLs69qNglN6LaIZ5oi1wQHvOLTLhwQ2VksBBXhceiPODwMiDnuuOyauCkeR5tNY86MGTlya88xQHwh8KCB+5QIphl5xeDMYak1Cx0nbkNmN8DSJgDbH7Ppi/lThloHi2HE6U/bP5wo1RTpzZgxkagA5w3W8vdn6Jn1dyG7Sq7Ctcj/ZjjNssJEh4JzRE+itJHQDuztfn/Lty/eEJnzt8VWngaOLetpCEn1raWW2FmwyTgzwnA0sddFB4Fo0GxeFLwMahPDM0EZ/PVnw7b/C6reRQdu4zZ2plrIEr1oWTatjeIqjDFWM771x2B314V/yZrtlbRf50e9pKEW7YJOuHaBOqKdk3YrlDzaJQID9JAInv12JnUVGm15LTrctf19EZzSq2Ms6LNwnNbaHSQvUCGR77+G5Gf7yx9QcpKNUfiFzsSqFS6T0jZ8h7w+zhgySNAbkapBk4N+VnA+b8k96bSC2lpn2ysLkLBkuPQjEtz0LArATNF2HnmBsI/3ILJv/2DmJ8O48YdwVKUV4/a9MXltlzFkWXnwk7g2+5A6gHVVVp6Xwgvu+XMKAUjynxW8bIidtVSZ7a2CearBCl8SHgkNMf+m13pQ9Fv9g6FJfUcYxGafvWZhi+95yOCO4d3L78CLH/SHIDh1NrWMpPdqT/M/18/6aTZWsbHrbg0B2ARDPBxQfMIyA/n4jFH5vhktSEuDky3UgS+Nmp9HtVoHu0IGa4uT2hz/WWWJxSZrXXlZ/ZUMlvLrS9ttx7hROasI78E2RckmfP88/+ZU2r9+rxos/DcumK2Ts4wZ0v481i6ecOCB8wvcAcdpHJyVfNoeb5vngU+a2Ze2cOKg37/8DCw7Alg/0I7/bKYKIW12om25oBATi5XqCvCsaAcb8Rnm/8FACzbdxFFUhWX5TnxZMCMo2jrpY+bx+HYR0Wb5VcWK6my5LdiZrsOCie9L1W4BJU26o7PY8lnmRc9Wy2n0ou24ybLC5dmsdTUVFy+XOqgfeDAAUyYMAHfffedZh0jqgbSB1x47ydn5OK1lUdcqleaGLytLqX0y62LDgJmpJsdDAKONI+OBhlBAmme6ZwyW4veYWWaEZ6HUtlYwXxvz+exZB+7Y9PuL8y+NrmStEqqfR4daB7lcFXzyOkkgjOzXalN6vMoc17sTVBqKDDKnRuhRCG4F5zVcCuarV3xjZNbBtLOdZVo6pic8OjCTGd1PSnIsluutGENfR7VnjeLCfT4qtJtnDTaWt5sLW6v9DfFM+VC/k6dRHi0e1hKwmN5ovblXPB8TPvjJHp8/Bey8uSfGavwKFpEz7xNbaoe8XKmcoKfGp9HObO1rfBoq3l0IbiwnHFJeBw2bBi2b98OALh69SoefPBBHDhwAO+99x6mTZumaQeJyofNm53ghuckD1xuoWvO0tKHrQYE5lVmguxDVtL2ngsS30FNV5iRcYoWLHTPcUwx+EV13cItDs3WwonEcaoeVWRdVF+Hkm+k2v2lwqPJKPbDVEK6ZjSz1Tzeyiu0KSNln/RecZI7cve3kjbWWc2jMMm50ylEJMjd43avkfg34ePois+jBad3kTuXqiZ1uRc+d54Lqdnaaue0brIrPHIcdEqrb5XuoLIngnIOxy6LpaRyRVv/kJCM9OwCLN8nn/bMcvqLBMKjAeZnRDFVjwTZlcuczisq5zcpSdXDm6AzFaAmJxjXXHnRLmdcEh5PnDiBrl3Ni5j/8ssvaNeuHfbs2YOffvoJsbGxWvaPqOQ48nnUu/gwSJ/rulyWoFHeruZR6phvNFoGLxejrWUf9NJtOTmlecZ0cuZTlcj6bwtlQzmzvJzmQnaiUAiYkUP6pu6K5lHtmtVSs/XCXuZ0Go5QYbY+edmxL6ArCd0doqRNWjlMWrD0I8+LXkIAmM261t/LyWxt/UkiPApuRKvPowu5M50eDVzWPNp/Zp1GaXlCwXmyEQ5FPo+KnneCj+r6JxJSJWOXTRXWa+RBHzs38jzKyXeAUHgs9Xn0hYIgrTAHMZ6H5byUvgvIP2cfrT9pvyOA2WKz5kXgwvbSbaZiYH4PzD4zALHenwl3lK+vsmsei4uL4ePjAwDYunUrHn/8cQBA69atkZ6erl3viEpNEPJgSN0L4YMgFR51Kpbdk0PqI2IjPNrRPDLJb6N+2G/WlrisebT/hnojq9SvUwde/o1WsebSPskJnTxjCEQeJhuWovrNJPNGUYS1nF+cmxMFp4PqSU1J8yh6+3bCbH1dYZCWwulFbfMmE15ZLg440kNQN8fJCh9KydkFO7rwu8K5y05VrmbJw8DMYOXf3V3yTNZs7abm0YWJznnNoys+gQpl3dC+mZ9p+y9qNsGCot84x8GEqoVHsTuDeDdJHRYNfUUJmNHI19IyVgo1jz4wt2N7i8nPFQErByPOezoERmvFl7RFfyfLd0R4Xnd+DByLA1IFy0dePwnc+Fe2fVkqu+axbdu2WLBgAf7++2/Ex8fj4YcfBgCkpaWhdu3amnaQqLys8/4ANeIGASd/E2yVCI+uah4lAlgd7rbwR4WAGfnJ4eadfBy/kg3Fya7IQQoR0YNuGzCjF/g8uqV5lNnGM4ZJhl/wvGETeu8aWtIFhXh3R2ZrxrAI07HY6zP5360oRZY66LVoohcMwsdWKmsfHCVwL+GV5YnWoAtzF8UC7uFLt3AlSxyQIBYedbLnxZW0Sg5xwY9NNOHI4bbw6MA30+YnJvkq1DzKmK1VapecHg+cMCPyPBO8uGkrPJ65fkfhuqo1W6vIgeuSRlml5tFNwfmNX45i2d4U5UI7PwV+HiZvcZBb/1klSpfcMsYKBXKL8GijsJC75/Juwit1D7rp/kVdZJc2pCIA0K6wrpoqqnn85JNPsHDhQvTt2xdDhw5FeHg4AOD333+3mrOJuxuOA5rpbLXQNmZrVzWPEuGxLrJKv/BG+QEhOxVI/BFeEGtZdGD2X+gKHK05an8i0ptK041wYDI5vezVXNoxJTetltxl8UbZxOCQndBE+2RdRHfuOPrrj6jvoFJ9dtuHWNg5txX4Pkp+/5Jy52/k2PWP3XPiHBIXvlS6QScWBnmZhNt6Ub/lA2a89GUwWDuT+1J1nW6ard1cBlLe51EwvcxsCFxSsZa4Oz6PDpLgP7VgDyI/34FiE+9A86j2uEvL3cwplhdkRQEz9iOaHWse1QbMCJ+zYqXEMSWNuh9tvfXUNaw+fBkf/PaPcqHtHwGn15emUhMiFHDVurOUIF3BzFpNyWahQO7LmS1I0lvs2p0izNt+TlJx6X4MXKmlywk3iczcIhQUuWiSrwSaR9s4dhX07dsXGRkZuH37NmrWrGnd/uKLL8LfX2H9W+KuQukWD+bEk7iLsqOM2VqQ8sdUKN+Dda8AAP5PctfrwJtLKz2YhQ6ERwcmMJ1A8zjHax6OG/var0+xGXmztV0zjKzPo0IDRpWBQYpJ1mWQEZR+S7qCH+IPQ6iPRnqS/P48j6TULAyel4CQ6r7Yo9DMZK9leKr4b0EfxZrHrhsGohYWIBPVrNtEmkeF49AuY4nCFK5VA+76PDoZbc2DiTQPoiTh1rcjoeaxEPjzdeDVvXa7YbN0nCOEkzwzYUzsQcRk3kJnSTETz3DkUhYA4MKNXLSSfeFz/Vowwb/mj5ZnTaB55OxpHuXN1iaeR2nol1qztaCcI42vVXh0/didWm5VmssUkGjNnRQelbpdsl1O88gkO54+fwHtz48CFNLvMgC3840oKDbBV+VzlltoRKfp8RiuP4mP1KSaVDoAGyqO8OiS5jE/Px+FhYVWwfHixYuYM2cOTp8+jXr16mnaQaJqo5XZOkiYI81Y5NQbmh68/X4UOJ+LUijocQLhsb0uBa0u/iS3i3w9ojptf5f1n1TSPNpNEs6pjyqXChoqfR7j9qfgxJVsjF+ZhNSbKlcTYSZsPGHWYKdlKyeMbs1dEm+Q+DwCQA+dWDNisPF5lJu8zabObaeuITNXcn6KcoGjK+13347vrfmzRlGuJrHpzyb1hyNkNT7KdVy/XSC690R5HosVlvv0DnTYDXeira/cysNf/15H6i3bFXWKTUJBDfKH5ta1kN4/tuZxqXDIJGl85ITHr7YKkrGr7B9nR3hUTD3lhvBo95qd/wtYOVzxZ55nKCgUPNdOax7N3C4oxsF/k8EXml1XLPejTkZ4NPFM1E5v/XH01h9XqNnMsn0X0fWjrao1jxYXGpcXxdj8P+CizItWBdI8uiQ8Dho0CEuXLgUAZGVloVu3bvj8888xePBgzJ8/X9MOEpUT23Q98rhstrY32BkLnHrIdOBL0rQp7ONQeJTRCAp8yHTFYl8734IbqvtmvxWFMV8pVY/d5QmhXniUaihlBlGjiceIHw5gye7z1m1DitdiRdxyADJaPyV4kyqFCy8V0qRBPbAV5MRmRHmJotHBGdi/ajbG/HgI0XMlK75sese8frgqFAR6rczWEr8xnjFUQy5+8PoUDS+vd7y/k2ZrDgz5xSbZorKaRwDwCXLYDaeHA8G5ZHYmc5HwqKIuEXvnAd8/6Jz7ioo8j/mFJdfs2Cr8nDUcXXW2gRO5Rc7n7xTneSwWCYzT+LmY4/VN6e8qfB6v3S7AW78eVVzQwe5Qu+wJ4N8/FQsv2ZOCq7cEvspOah4t52TEt1tx38oImD5rAUDe59FitjbxzHE7Muf6doERJpO662E5TJeFx8NLzUFytjW7Vl8Z4JLwePjwYfTqZV5o/Ndff0X9+vVx8eJFLF26FF9//bWmHSQIKbvPZmDe9vPKBfJvOfUmXSpEaGi2FmocTGKNmXOJp4U+jwpma6k5TLQkoXqfMKY6Wa80H6FtfbvPZWDXmRtYdUisEXz3zkwAZm2vKhytPmEpJh3KdLaaRylqoq1DTv2AHqdmAIBNwA1OrFXVNzNKGh97uzhxn0g0jybG8KrhN0Tqk3Bf4puO95cNmFFG+qSINY8KeR7lhMe8TNEShOlZBXhh6SH7jRflCoK/1GmCik2C55EDZE+80v6b/wdcPgAckCyCITSZS+8fGbN1MJeJWK9PBH0qubfXjEU1dhsvGwRClhxuah6rIQfR2IXBeoHzh05vXpHLxpxcWscbvxzFL4cu4zHpy5O1PWcEGnHZhTvPi/vrpObRgvcNs1XBy2jRPFpas9U88oypGFcE7gaCz0aTusA0yznRajneiohLPo95eXkICjIPBFu2bMGTTz4JnU6H+++/HxcvyiftJO4u1A4nRbIrcNjnP4v3l7ShsO/WKU7Vp0dJ4m6lfF8Ftx0cj5zm0WR1odFJBubad/41TypOmiDkhiGeyQxQQs2jcJCUm3BLMDFg3NL9UGU3kGoo7fgKSo/QollSLTwyk/XoFK+3HLKaR0lfJAEz56/fQTP1LbhOOZitGZOkr3KEk6l6OEnWAPHa1jIBM4Ct8JibYV4aMKAegDkAgDVHrph/87XT15khQP32wCu7JQKbcn+FmkcTD4Xzbt4//XYhZJMiyfnrWZGYrWWShANAX/3R0j1UvByInh9XhEfBdZV95i7tB+a0B7wksQqWvl07iUfTvsIpPIabqC7fnlOyo7jwnQKj+CCdjba2VCvayKyBNELrgg8smkeIhFQj08HASdoV/C48n0ajCT6CdpT6ZDlMhxH0zlLZzdbNmzfHunXrkJqais2bN+Ohhx4CAFy/fh3VqlVzsDdBlCI0fTmLVg+mTjpwSHFB88iEZmuTWGMVnHUY2PuNdBf5qu03I5/7UfRFxhldZp/s/GLcybP1FZNFzmxtLARyb1o3eXMmhCDDRuCzDDh6R+fcguA8qhY4AVmfR6nZWqp5TJNqFh224Xggl9c8yPnGyeHE/S0xWzuTS9S8j5zZ2v755hV8Ho1KbftI5oaUEk1W7nVVXRRxrcRHzV4eRQHCl1TlaGvztjNXFVYw4hQiKmC5UvbN1jbVqbifOdX3SilOBcwUl5iMixWe/fndMZRfj0+9lJceVuuiVFIaiJ8MrBoN8Dzyi00SM7v9+eCd1ceQI8i6YLmMojGcN8m+vDqleVSIkufVah7dNVsr16xxfa7jkvA4efJkTJo0CU2aNEHXrl3RvXt3AGYtZMeOHTXtIFE5UTueOCs8FgjKayY8WnweFaKUOZWmUwBAzjXg607wPvmrdZNeTmOR8LV5De79C21XDlFALi2FnCl7yR6BqVg2h5rMeeM4mxRGikjN1owB33QBPmsK3E4DALTb/jz2+L5mE6TCOat55I0AYxiu34r2XLK6fawNORIexT6Pzt9PTgzkStrGsgqYkd4XPA9c2KG8v+wa4vb6xiTrqssIkjZma2nAjAbPr/A5VenzaJPQ21qXg2shXfLSTt7G0lQ9ytXZ66+1STmB1Jl9nF0vXYH2OieePUckfAX8swZIOwJAIvg58EVceTAV3wrS6sim6uGNgoCZ0rrFPo8OXjqY/DxjNEqWFlSg1GytMRVI8+iS2frpp5/GAw88gPT0dGuORwDo378/nnjiCc06R1Re1PrBFDgpPN7KKx0MHa8Fqw49eFtFhKtLneVlmP+E9ZtkNFo6PbDgAaDwNvjMZOgGfqxQc+l5lFPoyJmt/0m7DXhbCpSe38LiYrPJRcHc4q1aeJRoMxgz+00BwIWdQMRQVL9q9qv6j36rqKilr6oDZsAQlhmPwV4/qCxfgk7vUDbRM7Hm0Wktgapb3CJEKJhX7ZounZgobKKtJfsnLgHWT1Te35kXpJKaTSKBUdAVq8OZRDdh8BF/1yRNkVS4ktcOCn0ed5/LQHvGbDUnjjS2diZusxuljJbQrubR8fGLhUeHxW3qzVFrTXCiTtvfnECo4SzJQiHKeqDC53HD8dL8waUaxtL+bT+ZhpahwTZ9U4q21tv4jIv7oeN467k3mdSl6inVPGr0clhas/XToZRMdGlSS+P61ePy8gkNGjRAx44dkZaWhsuXzUmKu3btitatW2vWOaLqU1DsXFoRYboUrUwC1lVfRMv6OSHUOgrMMMloHjm91Rx+6eB6dUE0MkVMvG2KD5GGTSAUjFq8z1rCpjuAes2j0U7AjJfYWc1mYmEW4VGtzyOP+rmnHReTfuf0MlvFiF4+ZPNlOkKN2dragGBrOZitpffT4aX297fjAygHByaKsRFqOksFMGk+UJurZL9PahD025LhQO6qCDWPn20+XZpOSFJXsb0M/lKztTDSWxqtryLhuDqztfNaauF4cC79Jv5VMsM7hfJxCNOcORzHhC5AJeOI+Dl0PO7mFdmWEQrZa+IWg8s1Z7RwOWBGmJ/TWgeTRFsrXw8ln2+nkZ5Pwbk+lnrL3drdwiXhked5TJs2DdWrV0doaChCQ0NRo0YNTJ8+XZSihLiLceKpKXQiaOZWbukkqaXZmmcQaxZc1TzKoOdl/I4Egmqx0SQ7IJprFoofMv6Nsj6P8sKj0WgyC+oy+3Bg8IbaaGs7ATMGifAo91YP54RHV4SMXeduIv4f8QpH0lrE2k/m2PcV5ojr52MPIuFchu2PCufV5rcyMVsLrkmJ2doXAiG/KNd2HyGyZmuGtKx8bPnnqo1QwIEpah4VzdbS86OF5lEoPNo5l0USoVD2xfPrjigusJN/VKpJlaxCIp+Q347QVUZma+GxeUMY+OE69vYVXmaHeoBCgSBbkgJNNBao0DwKBXxLc0IBdK73N6i3cqDNdotlZe5f53DuuoMUW7s+tX7UgUd33T9I8nkRtZL/KC1j53pYXqDcto4d/xU4sEiwofRk+yi74JYLLpmt33vvPSxevBgff/wxevbsCQDYvXs3pk6dioKCAnz00UeadpKo2hQZefgJN/z5OvDYl7JlM8vIbG0jhDkzqTuYBDkm85YrGHF14HErrwgBPvYfRzs+/uJtopU9SgVCPcejyMTDV0Hz6MO5KDwK81hKhEfGONmZxxnhUU1UqpRinsOCnefwoLdwqzTPo9AEpa6Nd1Yfw99nM/DXv9eRUlNyYDLajFLh0RWztRPIJAkPguC6OFyfXU54NKHHx38BAL4e2hGPh4eIfrZaDBhDtVv/wB8FyIOvsuaxLNKWCIVHO1pDaVYHWeGxOA/c6Y2S+gXlpD6PwmsqTTLPZK67BKfN1i4EzAhfCN2x1Cjue3EP6l85C6AOAPOLg96eqCnIlcnyswDUF48FKsZd4bW0nGbpeGK4c7mk36UIj+GT9f9gEexwLM76UQeGWK9P4MMZAeHQpxRtzYR5Jt1kzVjz/037AnVaiOYNH4Nn/R9d0jz++OOP+P777/HKK6+gQ4cO6NChA1599VUsWrQIsbGxGneRqIw4c1sXGiUT1yF5/7ak1Czs/uULPKPfAUBLzSMr0ay4qnm0j15OeMwqTWmlA4+sPMeCm6yWUcbcqpQ3TQferOWVqad67gU059Ic9gGAjdl667ELpV8caB5LfR7VC4+uXGUGHUKqSwRZSRmp5lHN5Hr9tvDYJWd+8UOqe1f6sSwCZhh4BgQKV10qdGC6dLA8YcJZW02rVUg8vQF9dzyN1d5TzVUpah4lx6qx5pHZ0VrZNUcLsIkUP/xj6WcbzaO0Tu3N1uJgEgflTcXAzs/QUVe6Ko1QeHRmvPz77A0cTMl0vO+Sgei87zU05q6Zu+BI9Si4D4tyzWZXZzWPRSLNo7k9JZcboYJBnHJH/ZrTiuOCveU7ZZKUu0XeTZtNPvoyeBlzApeEx8zMTFnfxtatWyMzM1NmD4JQRq3Z+rl58fjUaxE+8/oO/ijQ0OdRxmztFA40jw5975goEEipZrla5AJmREfBiyePIiOvOOiNMWyU3S5l/zmxOXj5rlPWz2npl5G9udTycA8nFjq8+Xw8o9+hXmus2hdRXMoEHZrU9lcoa0ZoNmSMqZpcDXpBO9L7Je2wcq8UczvaadPqauW4X7xMkvBAZzSPDqKtT129jftnbrN+5yAQtA4vAwC00ZmDphQDZrTSsir00d6ELRUelZ5JG+Hxj/GCnexoHqXf1ZitVdxvon4yBpjs+Ood/B7YPgPfepcu1OHNlZZ3ZrzMLzLimQWly+M52jeEMws3hy858MMTCI+Fd8yyglB4TEyRcQeRIAx+snTLSyEAT/iECsccNS4DFvTgbRchAFSarbW6521HQV8Pm61dEh7Dw8PxzTe2eeq++eYbdOjQwe1OEZUfZ+QwqT+SEgbB26U/CjUzW+skaUecxd6yaGrQc+o0j2rzPIrOiyRJsFnL696Atv/cVdF3P4FvXf2NL6D63k+lu4j4zOs7cYSlXVzrq9nvU3xd7C1PaNbgqhEehUOmE3keBfeIKFhDVaCU4/vrwjXBpG0xW3NO5K1UDFQw9+/Y5WxcvV0a+CVKEm4Ut1P6ODvQPLp5H2bnFUs0jzLnae0rQMZZFBntvGAJsB9trax5tPF5LIto62NxwIy6wL8Ky03esF3eUKx5VD9O+aEQ1VDqJ6tWCBq2aD+e/DYBP+5JkS9QVCo8FpdoHoX9+uYvx8FxNXEbdSD2WVTSPHIizWMpOtXjj/nYjbJR/MrnpPQ20kh4tIZvlx6Fd2UUHj/99FP88MMPCAsLw5gxYzBmzBiEhYUhNjYWs2fP1rqPRCXEmSWr1K4yI5z8DTBq9lZX6vPomuZx33lbk4IzcGDIUtQ8OljbRkboEWseSwdVHfgSzaN7581bMvD6C4RH2bQXMqhOEg5A3QAsLsNDByYRBGzyPAoEJp7nVU3mz+b/gtcNq8ztOZUkvLTu6C+3YtWOxJLNKs6Diut1J1cgwJUEzIg0j45QCHRUci/ghC9cEjcGRbO19Py6eR+GT9uCvMJS4YiX054eXQHEPqpa82j3PVZyPOKXRuejrdW4bogEvuxUc70rh4nK8DzD0O/2YedZ23HIy8WAmV76Ezjm+4JgS+lxmHiGVYdSkZxRKlwKz+fhS1mY8rs4v6sVgc8jn2drtuYcBNzqwOOI78s45PsKfFBkbdWLUzJbl/ZL6ALgzIIDOvAwyYhKp9OVgm6YIM+k1ppHgfDo9ELw2uKS8NinTx+cOXMGTzzxBLKyspCVlYUnn3wS//zzD5YtW6Z1H4kqzq4zN1SVEz6IBs6k2YP5kP4g9PmuC4DHLme51b7ZbK3OB2fLP2Ktn4m3nRSkqy1Y0Ft8Ht08b9KobH/O3rJt8jgzeLsSMMODc5gCSjgxm3jHZms9TBieE4vxhrVoxyXDqVQ9AkFji/ckPLMjEsi+7HB/6b5KCLXyZs0j75zmUSF1idI54SDQ0hVLNY9KZmttNY8AcFIwgSumicm5ZiM8Kh1XyNZX0Ud/TL4eqXBq12ztWPMIAN//fcHu72rGuPM3crD3wk1czLR9Dl3VPEoR3ulxB1Px5q/H0G/2DucrEpit+cI7AJhoaUCpRlD6DAs1jPW4W9Zrrmy2ZgqfnRh/FDSPszacVNzH0m/NV5ip7JpHAAgJCcFHH32E1atXY/Xq1ZgxYwZu3bqFxYsXa9k/opLijNl61kZbc4scQoHDB8Wama0f0+9H+IbBcHUy83Yz6k1fEm0th1Rb9uKyRNF3qdnaZgI1iSePIiOvLqekHWyER0jzPjrGGeFRXW8lWiFwDt0J9IKJyGhybM4X9rmnTkGzYoNFiJCp+9w2lZpHx2VEkyfjwRc68HGUkHFHPpm0vWes1GwtFlpKU/ioT9UzyRAHV1iakFxanR2tldqAGbswE3BpX+lXaXuy0db276kZ60/Z/V2N8GFJ88XLvMz4cEZY7kGltFlqEPbj0EXX4xqYIGWUyWhrPRLebykZueg0I17xd0PJ4g4mnikHzAiOWdiW3ok8vjowWc2j0rVhrPQZ0Ew3yMlpHsvAh9gJXBYeCaK8kebs0nLRed+8NJfNaD569x4jHXjkFir57NhH6qtnE0AjMlszFBqdS8ouh3QlGlc0j84I/mrK+kIsfOvAo0mh+KVEetRCp/lik+PAHOF57ag752SAle05LzCaHNxz6rRXgMTni/HQOVqPXYJ42bVShMdcDUKBlClqHhXvLzuax3GG39CMu6K2u1aEY4Cs2bqEIpNESHFFkOJNwA8DSr8LfR6ly2GqMFurQc0YZ1niVTaoA6XPqzvjpfA+MMiYS9Vq2C5nlN6XJpPJ5iVS+Ex+sulfG19wkQAIE3hmfjFQ9nkUCo9C/0f1wqNewWxtqVvuZVx2zW2N8faw9OZSnkeCcERZeGMIBw4tNY9WXAx80ULzmF+s4FvmQEAxD1Kl56XYxIsnCUnATJGRB894hUXc1CH1L3JF86g+YAbgVGgJWutSRd976k6gVtY+0TapeCg0XRlNJof3k3AiMgurrpmtLWTmFCJEzaSrymwt1jwyJ4VHpYAZ4eSe4DPe+pmDHc2j1WztnM+jUz6aJfUJr5ldzaMTCxEoIjXtC4RV82MoE0XvppZfzRhXKjzK34/eKEYRvNzM81iKwY2XZY4VWyszGWXGcIfWArHm0cTzKC7IwfteP8m3JxIehZpHJ30emd7mcbdkr9DLCNMmq9laK0pqEvTbQVrgMoc0j0SloNBoEgVZeKPYLTOMPK7V5+Wm47IOPPKLFMwuDur2zziOxtx163eb5QolATOFllVm3EALs7Uzgr9snkwH1OJszba20dal58FoUpp65csDFm2TfWRXmCmBZ1D5wuL4eokEesY7zusogVPQ2gmPWehDaQ6YKfkiER6VAmZyCoqQePGWYIv4uJx9ijgwkQbR3gozmpmthV9FPo6QmK0dp+pRgxptYUGRfc2jl4aaR6OJl9U8qkX4ksPzJpuXSEdR0MJxQw8eRp5Bf1A53bfwmIW91jvz8gqGYpnXbR14jF16SDZCvzRtlEYKjtK3UOsmb83nP+dwSnZ98skn7f6elZXlTl+IKoTLKRMVyCkwigYOH64YOq3zxrlYn7uax+pcHt67/DJw9mOgxYPIKTQisOQ3nb0TmZWKjpsGi0ZFo0kS+FFc6stm8XnkOSfW7ZZBarb248rW59HAO1+/HAxAtG6P7G/FJsfR1q5ouuWirS3wvMrId6fN1gw6J30elZIzK01+omjrYiXNo1iYWbH/EmYm7MHG8b3QJrgart8uQD1JnVG6RNUTOwexZsme5tGZJVAVsTlHTPJZe7O1o3uy0GhSoXm0CI+unwPLmFJsYjDoLNdVPhjFgtHE2wgYovuUtzVbR/D2fUDFmkcjeMbA8mx9MFlJTk6lIBlnhDodmKxgzoFh15kbAr9zBstgrNkKMxIYX3qVPR0w45TwWL16dYe/jxgxwq0OEVUDver0Kuoer9xCsVnRuwKZrX307g8R9xafA356Gpiajeu3C6zCo5zZ2sQzs6nkhm1OtJSbueKBPP2o9aMl2prXuXfepMJjAJz3eTQ4ce28eOfrV2Kut21+WsBitnYkPIony9wik/U6KcEB2H76OnqbbF0FbE2d0gLO+DyWCjZFxUaAc1LzqNCGPSHfOmmaxMJ9qXuhfF7NQxdv4Wp2ATZsOY3PvEp/94YR33t/rrrPOohdNAqKiktatb2OX8SfUV2vIhLhUSisMsYUAmbce9bsjXF7z9/E0EX70LiWORm+os8jV2zOLOWWIGvet8jEw6tkvBMLZrYUm5iNgCEcOzjeaHN8L/JxgGkeoPeCHMLr7QUjjCYGo1eATTle72NTXuwv6ZzwKBdtbTlmxoB3DD9jkD4BjxV+BKCuVSuvXbS1RSgtHUc8HTDjlPC4ZMmSsuoHUcVQI9iZ3+jUCV53Cottoq1rCJLYaoOrD6O275f5giTSQcZMPKLbhw18N2s7t/OKULPgkuzENGheAp5TWLZKx5l9dHgvbQNmpMEqanBG8NdK82gPo0miOZKhuSCggwPD7QIjAh1ceg4Mo5ccxPK6GXhA8pvZ0V6N5tFxGaH5b/6Os4js6kislbbh2GwtRSmhNq/g81g62TKsSkxFoKRupVx9SugkPo938tUvOecSEp/H7LxC1La4otkIj2rN1upfWKS8s8acUuhSptm64Ejz6M4oVap55K2rLCmtGw0A3XX/wJRsew/6CMcKZqt5BGDOEKH3krVeiRQInBEmnsFosG2H6b1t+iUSJJ3xeeR4WeHR0hcTY3jZ8AcAYKxhAxZhpOZ5HlnJSltGo8naE6/KmqqHIOyhJgm0MwKEWfNY+iDW4HKxzmeyS31TxEWztbsrzEiRTsrfen+Nh3SHSjfs/hL4pguw6W3Z/ZXedi0+jyYV68faQzrJO+M/ZMHghOlcO82j8vRpNJnsTq7NuCtY4zNVtE3twokAcOWWbSocJvWTU0JFGaE5kAOPUylORi67kudRpl9hXAp4k0lQSriPubyJZ/DS62zOnrNaGk5yBbacTFcsqwkSAVu8JrMkf6pVeFQfACKHPeHDxyCevpWER58SH2X38jyWCo/6ErO1Un3+KMDP3h8h8OfHbX7z5sSBXbJ1lJxnuYUm9CLrkxEmxmA0yGgedXLCo9Bf0plUPfLR1pZrI0yXZumf1nkec0qS4ZsE2m4vz+YIJ+GxKpCamoq+ffsiLCwMHTp0wKpVqzzdJVUPpzOmg/xi8VtqGJfiSrfs46rw6GYAioiiXFmNToTuvPVzzX2zzB8y5RMMK40pXjCh0Mi7vcSwNGDGywUfSmcmMq2ER3vCntGBz+MDuhNO1WfBUqfc8fKMqTJr3sp1fPxCzaMODF4m+byNiigIjxwY2nAXURdZNtt5ntmstbzB53949naJhcpG82g+FwXFfInwKA2YcV54FK1XrJmJUAFeGtwh8LeUah6tgoV7wqM93zwfg1j1xMohYKbYyKwBgkp3v9oAOo43yruvmJQ1yH4iN4diGHmGIp2vTTmmMxdUfvlRP/605VLsCo/CS6wHj2Ijj4zcopJ2tLkns/PM59RkKr0HDR4OmCHhsQpgMBgwZ84cnDx5Elu2bMGECROQm6u1SdfJPql4ONU+WMkZuTh+OUscMIMyMFEpTKAOd9MycCf3hnz0nmCoZtKVOyQoCWa+KEKhkXdb8yg1WzuTdseCMy8OXuVitubtTq5P63eKvqu9d62pfWVmWrM2wXE9U38/7rCMXpIMmTc5dy8zhXuihe4yNvq8i4O+r4q2+3FFqH1pk3nJPAmDc38p+SQvPGbnF8NLz9mcQ2eFG7PmUd4sWSZIzpEoWIfxYimi5POOf6/DHo5esp3RPJqY/TyP7qfqYSgy8dDL+jyWfravwxfUyXh5C5Wd8clX4F/uBXPmCNlAes62j6IXDSesRf/z+rlkRSkpJZp0Jm7jTqERH6w7YdO+EKPCtVIir8A83xlNtveYpyDhsQoQHByMiIgIAECDBg1Qp04dZGbaRqCVJ2p9Hh3BGEO/2Tswe8sZm2hrzTE6m2fOjKZm69ybKJIZDYVvvkoaBgtKQ7cPiswrzGicqqeyCI/2tA2ONI/tdSmi72oFFR+uGAHIl237l4OpuHTTHBV9MmwCrrKakhLmNvaey1DVlqhvJaa/QiYfeCDFaJR/nrrqbIOyLETsfQ04+rNypZKXnMf1e/CeYTlu5xXKmq2dNauafR5tBRil+z8QTmpjpUheLkXCo020tfnzzjPX7FbpjtnaV+L0pujzyCkHEqlFxzEc8IlBzd3TrKl6lAJm1FpTOaaQW9XOS7yfIErDonkUauOslIzJSgEzzt5r3jLWFTmztbRepXMh50Npj1yL2dokNvt7kionPH788cfgOA4TJkywW+7OnTuYMGECQkND4efnhx49euDgwYOa92fXrl2Ijo5GSEgIOI7DunXrbMrMmzcPTZo0ga+vL7p164YDBw643F5iYiJMJhMaNWrkRq/dx6BioFLzAAu1cMKB1pUgDYcUu2YedXe5PyFpVy5h2KJ9Ntvr4DZmGRahLZfiMA+SkpDky5k1j45MaY7wlvg8SjWRanBOeNTGbG1PG27kHafqEaLneDCmbpo84POq4iSy77x5TfU/jl5VnPydneg48GAlk0wB1AmPuxWEHIdtn/rDTkfEx1OLy8ELhg1olLFT1mztrOZQGjDDQXmZupf0f+CE71g8ofvbqTaEnEq7JfouuocVoq0dr5fuQHi0Y5r0VunzqMUKMwBQj8tC7WML4ejdU+2zrYN8wMxX8aew+2yGrOQlEh5LAmZkLSnWVDlKwqN71hdzHSX+jTI+j9IyUpwVHvMKzfOdUZiOyoklFsuCKiU8Hjx4EAsXLkSHDh0clh07dizi4+OxbNkyHD9+HA899BCioqJw5Yq8o3lCQgKKi23fzk+ePIlr15TfLnNzcxEeHo558+bJ/h4XF4eJEydiypQpOHz4MMLDwzFgwABcv15q7oiIiEC7du1s/tLS0kR1ZWZmYsSIEfjuu+8cHn9Zoy5gxvFgZuTlH/4yMVsXu6aZ0FJ4XLPnhKwQM9ywDUMN27He53/gOfsDj5Kg4otiFBpNdvPhqUEqLCpN2PZwRltp0Eh4tDepOdI8SuFKdE1qCOAKZesWml0ZZFKtlAj5zvrF68DMOSQBFMBb1T68nPYGKgSBXGWtqNJzoS+4JSs8OvNCAVh8HkvrGGdYh7O+I9BFRlv6rpdZQ/q51wKn2hCSdPGm6Lutz6PEpGh0rDF3z+dRfL8oWSS8NQiYEWIozMZPXh/hP/qtsr+rdulgvKzZ/tdDKfjP4v3YdOKqzW++gqHPC2bhkZezW1ufHaF2tLQc7+YYCJQK9sKqykrzaDFbk+axDMjJycHw4cOxaNEi1KwpNf+Iyc/Px+rVq/Hpp5+id+/eaN68OaZOnYrmzZtj/vz5NuV5nkdMTAyGDRsmuninT59GZGQkfvzxR8W2Bg4ciBkzZuCJJ56Q/f2LL77ACy+8gNGjRyMsLAwLFiyAv78/fvjhB2uZpKQknDhxwuYvJCTEWqawsBCDBw/GO++8gx49etg9/vJATcBMW10KlHy+svOK8XpcEnaeuWHdJl3bWnNcFB6D0+QHUVcoLHacb7DIzqltyqUpLtXlgyIUm7RY29p9s7VzATPamK3t3ZPOCo868E5FWytdU+sEJFMX4434/u8LLplzs/PMAnc+81G1j5IQ447AoSQ85hXz8JbJjepatHXpPg24W6L/5VCbGsyKfx3rR+k5Egoj2XlFuF0gsIb8OhqYUQ/BsO9y4I7Po9RsrVTSUodWwbmNbiagp/4ffOC13LpNeB3Uax552bJzvb7BAN0BWd9vL4HE4oPiEs2jbR2c1Wwt1EwLcNPv21wfQ+0Ab4nmUV0QmFwAjj3yisz3lkkoKGtwDO5QZYTHmJgYPProo4iKinJY1mg0wmQywddXHKXl5+eH3bt325TX6XTYsGEDjhw5ghEjRoDneZw/fx6RkZEYPHgw3nrrLZf6XFRUhMTERFGfdTodoqKisHfvXtX1MMYwatQoREZG4rnnnrNbdt68eQgLC8N9993nUp/VomYA+dn7I4zRb5AdQGdtPIW1R67gpWWJsnX6cGVhtnbN5zHin1madaHIWOxQeDTaMZfOtqNZ8UUxjCb5wdYZpJpGZ9LuWHBGy+RKKiA57JqtVSxPKETvpPCopHmEVfPI2ZjBGW/CjPWnnF6GU5g8W63mUa9wDR1eJzsuFEqBZMUmTkPNo3P7ODtpIygYeHA6AFtrinTpu63/CCxQRWZf1qcRb7d6LVP1OKpDK80jx9uOvR11ZxHr9QmacVdUt2NQMFtH6M5jofcc2X28BTlsvWCEkecVtIi2WnvhueQ1Eh5NjImFR076gqEkPDprtjaPuQXCZWy1XmHNSaqE8Lhy5UocPnwYs2apm8SDgoLQvXt3TJ8+HWlpaTCZTFi+fDn27t2L9HT5XGEhISH466+/sHv3bgwbNgyRkZGIioqS1VSqJSMjAyaTCfXr1xdtr1+/Pq5etVXZK5GQkIC4uDisW7cOERERiIiIwPHj8hGaMTExOHnyZJn4dwpROxG8YvgDc73m2my/cMM2Wlzo/+NXJj6PbjrUa0Bhke2qC1LsCS1BUBaAfbkiFJuY02b2G6y66LtU61vWPo9aYe+8mleYUd8nnRNma0B+EtELhDwGzkYrpmMmQGKaVduW5VgKVfo8Kl0Pd66TUiBZIQ8YNBAedU6J72aUVmFRhAOgM0/0tuswiwMlrt22HT8cXTuDA/cee/ek1OdRUbttFaS0ETb0JtsxZrxhLfrqj+J7r9nQqXBZsvTLWYHWS1C3N4wwr/BpT/MoH8zCFNw0nEEHBqOJ4fejpe5jUjcDpXMut1a2PTYcu4JCowl5RQKrD5mt3SM1NRXjx4/HTz/9ZKNJtMeyZcvAGEPDhg3h4+ODr7/+GkOHDoVOp3xKGjdujGXLliEuLg4GgwGLFy+WXT6uvHnggQfA8zySkpKsf+3bt/don/QqtSUGmPCI3jZAaMH1YXhSt0u0Tfjw+7uwJF5loKi42OEg7/QEWIIviuy8qSszzzhI9F2a19EVn0fNl5ZUgV2fR945QcTs8+ie5lEPk8Dn0VZ4BGyDQtQg3Eet5nGwXn7Nb7fM1gr3mcXtwjZJuHvR1mpw1mxt5AHozFEagyTnSPgyy3HyZmFHz7Ijrbq9/aXr3iuVLc01qo3wePS0XNoaM/fqrqGP7piqevTgnVqmFBCbrb04Zc2j3FKVwuvFNAg20cG8Ytenm0p9bG0DZhQ0j4JUPddZDawwRjpsK+FchkTzSGZrt0hMTMT169fRqVMnGAwGGAwG7Ny5E19//TUMBoN8GD+AZs2aYefOncjJyUFqaioOHDiA4uJiNG3aVLGta9eu4cUXX0R0dDTy8vLw+uuvu9X3OnXqQK/X2wTcXLt2DQ0aNHCrbk+j1tSoNDnV4jPxhfcCNOVK3+rEZusyXopMDddPATk3HJdzAmkQgBz2TG/2JhtfFMFoYk6lFupX+LnDCdc1n8fyN7komWYBICuvENU49blRnY+Atj1eg+DMMkjXSzGjd95LT+RLpjZVjxKOtYHKvVPScN8pMmtrpHU7K0hwJSK3Mzhrtr6ZW2STckipL3Jeh46FR9fN1lKfQGW/VdvIY3eo6WDd9BleS1TVowcvMkOrwUsgAHqjGCYmH/xieXFRykXpbtCgpT5pWjXpPayY51GgeTRBhxuoLltO1JaRR75IeCTNo1v0798fx48fF2ndunTpguHDhyMpKQl6vX31cEBAAIKDg3Hr1i1s3rwZgwYNki2XkZGB/v37o02bNlizZg22bduGuLg4TJo0yeW+e3t7o3Pnzti2bZt1G8/z2LZtG7p37+5yvRUBtROBoyz59bgs62fp2tYe59v7gdnNNa1SGgQgh8uaR84cMKO0JrEcuczXYXuuaB6d9ePTAnsT9Z1bN1CdU++2oHda8yhXR6mpnFcUHp0zpwOuaR6VcPgSaMfyoiQ85huBU+m3bQQ/e8K9HA2qeTv9EuKsoZsBVs2jo5JyfXE7VY+d/Y2S51jJXGy5F+yl/XGG2txtTerRg0eQt3PXQ6h59IYRJ65ky/ovcjICsytBPfaQ92N23ufRBB14B0nDOTAYeSYWHj0cMKPmqajQBAUFoV27dqJtAQEBqF27tnX7N998g7Vr14qEtM2bN4MxhlatWuHcuXN488030bp1a4wePdqmDZ7nMXDgQISGhlpN1mFhYYiPj0dkZCQaNmyoqIXMycnBuXPnrN+Tk5ORlJSEWrVqoXHjxpg4cSJGjhyJLl26oGvXrpgzZw5yc3Nl+1GZUJOqB3CstRIGEQgfxDLJ81gBEAY7KOG8LsqMD4pg5JniaiJyqJluXBIePaF5tDNhhHL2kzlL8UWh29HWetWaR9ejkN0XHu23zaCse1TScFuO013No5eOc8Fs7dyLl16ns/o82oODgjDBeLthzo6FR4Xffx4Gg+41SR/sR/RrpnmEfc2jWvTgUcNXD2dytxcLktl7l6TqOZl2G10k5awCs8jnUd7/0VXk6pA+L0r3p1FwH5qYzuGYroP5pb+wAvk8VnrhUQ0ZGRk4f/68aFt2djbeffddXL58GbVq1cJTTz2Fjz76CF5etmYenU6HmTNnolevXvD2Lh2Mw8PDsXXrVtStW1ex7UOHDqFfv37W7xMnTgQAjBw5ErGxsRgyZAhu3LiByZMn4+rVq4iIiMCmTZtsgmgqG2ofTkflhA+VcKD1K4to6wqAWVhQf06cwRfF5lQ9TgXMcA4nXLX+reJaK5bw2MRJ4bGpTn1AG6BgtuZKrzWD/HXVq3iZkCLSPDI3hUcHL4G3cotQS+E3pZRQFtOx9Licjar30jPVwRnSttWi0+kAB3lVAWWLgWPNo4s+j6fX44G69bAMDwrqkj8XHBj0MNnNxOAMtRyYrdWihwk1fDkgDzjFNwIHoLXOdrlLIbfzSn3dLSnD0m7JBFda/DwF94cOPF7u0wwLdp7XSHiUfyEU41jzyINzeF/qwFBsYiisQGbrKik87tixQ/R96tSpmDp1qmjbs88+i2effVZ1nQ8++KDs9o4dO9rdr2/fvg6jW8eNG4dx48ap7ktlQK1ZwKHm0YU6KzNqggBCuEzF3+wJZT4Wn0cn/H2UAjncxRM+j/butWDupuJvWqAcMGOGV4gdVqOJlt2nRKBXG22thCPhxmQqVtSsKY17lvtJelzTvWKd6pu3zPrYjnBW88jAqTJby+uNy9ZsHWDMAgC8O7A1vtx6BjqF860Dw2BdAhpqdI9rJTwaOB7VfcxClNrrkpVbCIvcZVnpSidz4uVyW3JgGBQRgkV/Xygzs7VUKFWMgNcbrJObCXo4WnJWB3OKNZ5WmCGqOloJesJBxRPaqvJGTcCMq/hyxTDyvFOpepQ0Yu7ikYAZO4KQK6Z3Z1AOmBHkntPIbK3jSjWP0pUsFhkfcaouR8+xPVOzktm6NPrXvTHC2yWztZM+jwyqzdbyx+MgVY/DJOF2zlHJ+dXr5IVxYR1avhzV0shsDQA1ShKkmKBTteqKyVT6nBpKnlljSVDsBlNX9Cn8AoAwPZFQ88jg66WHl975+0YONZpHRZcOTuzzaHJwX3Ilmkex8OjZ+ZCER6JMKAstoSc1j8ZyelRc0TSpJZjLRM3CK04lQ1fyxQOAIuZcrjIhnhEeldss63tLfqIpXU3I/JKklKrHuXOlFyRflprDnF0WzZGAZ0/4UdJwlyatdu8e8NI7Di6T4qzZ2hwwo85sLYejY3R0fu3tH2jMxFRDLOrkninpg/L59uO0WaUJ0DbTRXWv0vtfzbURni+vknuv2GgqqYNDHvMVlZNqHn29dPDW67QxW8u469guTyh//YJrBlg/qzl2i8+jSHikFWaIqoi3ThvhQCi4eFJ4NJWTh4fOhfQjzvDgjaVoc2Sa6vJKUcAAkAf1eVWlaHktfzepy0xgb8Io63tLTsgyiPI8irViPGe+33QqfGBt6y19AZEKi84Lj/afY7saW0UzaonGzEl/RZu2ORc0jw6iWqUwBlU+jzpFn0cHwreDc2BPOI7I+RujDFsweN8QMGbf59G3ImSnkKHLjTUAzPelmnvzmY6lS/JanqlSgarUxcbihy08/zow6HUcvA06TZ53mRU2bc3WCv7gtQJKx05jySuiPcw+jzx46frpHoSER6JM8HUyf5cSwgnVE4mlLTg76bqKu5pHR+dokD7BqfoYOPAKyyHmuiE8jrq/IQBgubG/y3VYyGYBjgvBvpasrF0i5EzmQpO01Le0mC+NSHb2fjAI0vvYaB6d1BY7mmTt/a7kHlHqj+be86zXlX2ScF6lz6NSqh5HwWSONY/qz5HSueDA4AftNI/uIrRYNLxlXiDCC0aZe9P2eB4p2mj9bHmeLc8Qb+OfLb4mOjDUDvCBl17n9osLIM45aUHt2tbC3KEmVZpHZk6xxpPwSFRxfDWStYQ+j54VHstP8+ie8Ci/7y0WCAC4gRpO1cegnBsvl7kuPFpMTloI5WoFAnuRuWWueZRpWyg88uBwiwVZf7NGJHOuCI9GRc2js8uiOXrmpKsNWXh5WSIu3sxRqNPcN3fPuYHjnBZAnfZ5BFSbrV15AXHs86iuTvMKN8rCum8Fyk5RJBPEFcpds7lXX9X/hs+9vhVt485usX62jCHiJT5L54v/6LeKrna7kECr5lGLl0W5pcWlY4yy8CiwMsBxqh4OPIy8eB1tCpghqiQ+GgmPomhrDd4WXcXIlafw6PpxKk02lvWpnRdMlaOt3TFbgzeb0UyaCI+lw9h2U7hiOXsTtSPzobvIax5L3eQZOPzPOBaH+JZ4uWiCVXh0JWDGS+jzyNwzW7sq4G365ypu3JHXdlnqdNfn0TXNow7qspeWlGecW3keHeFQ86gyDRZjynXpwFeovLhy92Ag8m20b295/YKn9LsV6zGURFsLX8CEL7ozvJbYBMwAMGseNXhZNMi4ZtkGzKgVHh0lCQcKjbxY20iaR6Iq4uOE2dqkYBYFxFovTwRZWCh2M+WJWnQc79bqK8J9d5vaWj9bNKfOCqasJP5bDkeaR6M9/7KSqEktApGEk04+fBTLedJnVi4q2cDxoutxmdXF00VTsYnvar3vlXzp7Ldlsk6a0vPrrAbdnXOmvNYyb/d3tRhc0NLzcE5wYIDqPI+ujE+OEqM7c47sLU9YkczWctpvA8c7/WLjBRNq4jYmGFYDkE8rJvxmuT7eGgmPepnVlSz16iUmdVtK972nVpBDzaMOPAqKTeL6SHgkqiJ+evU3dgqzt453BfF55MpHeHQ3VY/wHAkFBcuA7fxybsqmPkc+j3b9eDTUPArbsfcG71nh0TawRJTnUSJolybS5p2+7w2cMNraPbO1s4m7hTiKQHb3euh1nNPnxuSk8Jh+uxCx+y47LGe+js4/t47Or2Y+jx4yW68wRtpsU3pGnR0LDDBhttdCBHHm7BFSszUgPX8lmkeDNtHWcv6sOvCoh1s44vMSpht+UB5vBYJngxr++CC6vd22dBzDd7suiOvTYH1udyDhkSgT/HTqJx21g3kX3WlXu+M2xeUkPOpdEBb+v70zj6+iuvv/Z+be3CSELJBAQoAkgGwJhJ0YloKQCgGjuCKmEMCKS1CQumAti49FtO1jqUqx+qi0biz9CfVxLaDiAwVZJApVUdEqVhaRyipL7j2/P27uzczcMzNn5s5dcvN9v168yJ05c86Z7ZzvfLejRDm4KAWFwFe9naTKuj6PJsKjoSnGGxAewx+ClO0YaTK7tWkRdlt24WoeNdHWSpRmazsBM4F3Ktxoa7PlCY3Q63fA/SRss7Vk3aTPYC2xOIOEV/ccNi2nn5PAmHCShCvx4JyBsO5DSgw0j3t8Rfhl/c9DtuuNC1atEG54MUzeHfzNIOFXl5SElAnQqHl0Js+jnvA43f06MqTTmOxej6JsgTFHdqFFsvH8wlurmzSPREKSKosnXTYaQMe4tkGCD32kzw39XyJNdH0e7Q9sLpXmMVR4tG621tc8/miy9J2hoOLzPx+pnvCWzwPUAqiRMDriglZht2UX/jq4yoAZdb99UPo8WkMplIadqsemL+hrnnswwvUhAOAf3mLVPqeShLtlOyvMSKZBKlpEVumJlNlatM7d7ikolz/SrSMWqXr0nly97VY1j0moV4133fIycN2FnVRllL6eAXcJp1L1nDwTqLvxHrklhnMKi0+S7nCkuAay29Q1QuYKj7ENmEnI5QmJ2JMqiQuPRhPUbe612OfLR450zIlu2aY+Wj6PNqM2G2k8VjkYn2cBzaPV2vQDZswGe0Oxp0HzeP3wzsBGi50K6YfCbG3kZxnDwVYkz6OSxiX8fJYFOFXATIRT9ehRLH8V/Fv7HLjggxv1mOxaZ6vuYD2SdYHNC9my8HjawI82gN1oazMB2ko0eZHMX589Vj6PehpGPR2tHc2jMtBNkiRVChwAKnN9+n8+BurPIcmhJOGBVFTK++6CD+dY41zR6dh7/IOV/pKSyzQoKxnnAO0zRppHIhFJadA8/iCQg89sghom7xF29L/o7H/jVe9gobJWqJfC15CJIIWZ5zFJMSYpB+PA9Wsl8dOn6MEa4kh5mJmcRXweJSn8IUg5GRm3GV/CozKnp3ZCbfR5tBMwUx+M0g1X88jz1bRKqB8aQ43rzbAj3F2SddO3D3IwxYsIDBLORFB4dOukOgrghHk1Vj6PuppHToDkOu+AkMwAZrRO1dQjySHCo1LzmHTuB+Cv0xpWmAn/uvLWz3bBp9I8pngFxlvZFdJvLf+V9GcsS1qi7jcJj0QiEjCTnIG50GXq9yMxnBcUHutbdcbzvjFCZa0QrYAZGQyeMExMHkWUuzpgxr6RQd/8ZCY8GkwGDZpHs0FTBC9Tmq2NTOWxEx47ZoW+B8q1rbXCY0CDasfnMVlu9JvVCtNWnwMrgpYe2uekenAHXCh/Ena9bsl6onG/2dqaQHyaiQiPJml1kjO4m8NZnlCUWKXq0fuQ440bM8/falnz6NF8fMgmwiMA4JNXkOSQ2Tpw75T30CX5cFZgzlOJnJx+86h0bVd/oNDyhEQi4mb+l/aMiV8cIGK6YSjpmCPU7oNXlOKZGSOFylqhXo6e8DhA/tT28coAh/OKL3mrUbYB9BLYXn/uF6beeMZawIYJ3E6UgUE7hm3G0Gwtc9rW5nlUEk60dcskhp65/qTwWjO1dc1j+NdMe0/8Cwg4EbBgXbD2QjbV9ilhTBI2WxueU0oWd/NYebthvU5pyGIRMKP3cakdN86wJJyFx7LPo8w0HwGSrDYHA9zk6Mq1rfVWzxJhbHEuxpbkqQJnWqW6VZpHXZT9FNA8BouS5pFIdFy+BuHRCc0jfGAuY+Ft1NnfYdCZP8IlS0huwf/KDwdv1DSPPgxXRBBaxaMYf5WCgt2oZr0VZjb5eodntg5D8/i781erfvtEhUdf+CZY23Dadiv8GbUTqjpJuDXc8CLd4z/qJz3UabCsPgeGa1cLoj2D8P16/bhkO6mnJItma/GAGb375IUMpPDHpFGuOpN6HdCQSQweCwKzU+j5H2uvVOC35WAuzTslyaF3gKdxVeZ5DCfPbJc2LfD45AHIUiynlpEso7ai2OCoYG8Vf5r7PDZCwiOR4MhB4dF84DXXPMJ0fdkvWD6+QxZcsgR4nE/JEi2fx/4dM5AtHbd9vHL4dEZ45AfMnEWSudnaKHjFFzDNW//yP4UUHGSNkdOieR5jKjx6Q10RXIoJXW9C9aejsTZJuJg3qGW9fEChuhuWhUfnzdYu1KOP/EXY9bokJrwCS2PbPksCsVGSfCUS9MexY1KG4PrYoTiheQzHDUbJcWZtXBV1d3G7/OUki9dI8mnOi/MhyhMek9xS8LkJK89sg9nYrZQDmQ8dcrLMj1VpHt3CH9GqK0rCI5GIBDSPIv4fQc3jDW/r7mcuMeHNJUtAUiSEx+hoHvu0zwgvElDhB6MUHu1loQPuHttDZ/LUj8IOYKx5DJitjYcg3io22npF8zzG1EeI03YSvMF7rWe2tpMCxsXqGycWzYRsVXi0YuLVQ9tmh10Po40D2RNckvUk4TKYZc2jCEaaxx+kLNu+vU4Ijy3xY9h1AMB/WMvg3+cEglv0njWmMS0nyTLW3DIEP+3d3lJ/JI3ZWuKs+MLXPLqCz41ddx4AgNdft2qN6/M/Ap+vt1aP7BJaxQggszXRDJAbXqwfBZzNg5qAFtnc/RJ8kAR9Dl2SBHjMI7ytEi2fRzBfeM7cigFF+VWd0cLeOtQzfnIBHrqKv160mSBirAUMmK2NBVCegOqFS2X2VJYxbDOWg+25EyGbjHwelXkerQoQMryNq09onlvrq3hEINraeybsOgF/Tj2Pxf7JDWmCRGGQkJ1m/uFqFG39g5QZhvAY/jObLp0Ouw4A+A/Sg3+LrGuvK05zrkW/glaWxyhJa7bmCGC8KPMkt6SbRN8S9X4/UpfyNE8fAT54UeBge2br4DN2YS3Qv0asnxGChEciIrh8/heL5/OodVIO+uPovEASAEkWe1RdsgS4k4GKhfCafM19x8R9I6OV59EvPDqT51GphRvd02gJSAMkCXmZqdxdZmZrw4FZ0OeRNwF5Idszz8fSbM3Bg3rBFWasmq0NNI9GrgQ6fQwX616bYrgkZjmgx59j0lqqHrfLvP/xLDw6pXn8QaF5NFtdCjDQPOqMC8ln/2OvYw1Y8XmUg8JjGKmuGxQk+onADVDleZRMP6IDBN00WraNiHuWFUh4JCJCq2T/Q87zedQ1FegIezIY3JyBgUdwoB92OzYX3GJY9g/1VwrVCUTPbA3mDW/C0DFbiw5OIXAS7wYwE0TE/A+N+8Wbjo3M1vGa55GHB+d18zwqk4RbvXMyq2+MLNd8kFk1WzuR0sSJJSh5yJL1gB4ZDEkWTfFugQ/X4a49uqb4/4QlPIZvth5ZZM/qoOU4GoUVEYuS3pOrNVsHcB8Nb/lZXs7YZI7wmOpmCuExjGczoHmUw3xHBFaYCRD8QHEgxVm4xL4HREJSmOl/GXipenQ1UjqaRxk+7jqiPFyKgcln8kIKpVRo4HzUNI/MMbP1eaY8PzvCY8MxOgOVeZ7H8KOtuZpHphUeFffcMEgnzjSPUqPmUTvRBq5tN+kbZEinLNUrM2/juWo0j2b3TIszATOR0Ty6JWZDeLQeMCOieQSAC+WPudtjLTy6z1tbGEAPZcCMSPoi3WdN51rIWQW2+hWsliOUJnNWOpuxeSQGyJ8BsL7ikgrvOeCLjXjyzJ02DraXqqdReIzMO2UFWp6QiAgBn0ee2VpXeNQR9iQwVUSbES6FhpI3mChRC1fGnI+a5tG6mVJTQfAvlfBmZ/IKXj97ScKNg1fCM1vr/e6Slwl8r9dmnAmPKrM1P2DmniQR/ykO9Q0aF43waH0JOLFr5mWS7geeoUAfBilua6vFADbN1oJWDz1OooVt4VGyGE3O5Yz97A1Kvkdm8O8fIyA84uJf47m6/+Bn7g12uifs2uT2/og8yW/KD2fxBHjPAX+5FNbCfBqwuDxhsChpHomEp17f51H3hdV5+WUwcc2jYqBnJppHK87Sp+WW5oWcINyAGQUqjY+twcZY8+g10SgZCpdesYAZ3l33QdYEzDS2c2nfjgYdij+ztZ7mMWxTr7chKbRmUrKqeRR974zyuVptU5RhF2TDzdEsGWFd8wgkucLr/3m4bWuKnPB5xNnQYC2rbOswFd8zRcCMgNlad3zQG4sy2uFX9dfb6Z6/WhtjHG8OUKYBMz44nMTr9lL1NGqiY695JOGRiAxefeFRd2LU9Xn0QXT8VgqPZi+kFeFxv6eTcNmwcFB4ZOEKj4EJT2fis2O2/tjXYJo6e1yoXzzNo/++KYRHpjEB6fH1PwzbCofDLMvyMUrNo3YyCFvgCkxsUng+j6IYCY9mHxl2yUlz2zJbWw2ycbsk4PI/WTpGSVHbLNuaIlGLiyEOCI+7869RPZMiZmu9/JjJSW48Wj+Bu2/jnSPtdA+APeGRl31g6rm7seu6D4CsQs4RyoPDWPJRledRFvZ5HNWjTcPxsRfdYt8DIjGp11+eUF/zaBAwY0PzaGYKEM19WM9k/NtloNFyEp83uOpIuPRqn9X4IxzNI4e1tUNtrW1tNa8a7x5p21X9FhyEnWTbsKfxLWtt+bgk1OsHzISxbBqAxolNclijqUN6y3TdfZHSPIJZy9kIWDdbA4BLloE+19peZapqQCfbk32blg64y2iTadtAlmXVsyOycpjes9ahdRq+6H07d19hdhr2/uQxW300c1PiwRuPfJDAUjIBZjLnhCM8KpHEfR7TPQ3l4sDnkYRHIjLU+3O5cX0e9ZyUDXweXYIvi1J4HNzJeD1sBuA3qbOx09fVsNxXLBdnZWciFk1xUPN4Wb8OjT9saR7lYJ8C+JgEXLwIfTtmmS9PyPF1C9H22tI8qlP1+LQmoChTn9JKaBUSLUlSY2S942brhvcvXLO1KJ4U/bQhjrZZOhHI6+3/m1kPmCmQv8N09+vC5Z3weUxJTrHv8xjjRNABJElWvbtnmblQqxcoleR24/cT++oe90PROMv9A8R9HpXwrE8+SA09NxEe6x0SHmWXrstWCIx8HolEp8FszXOsVr6wPuXL63C0dYsUs69jCe+kVGBp/WWGpY4hLbxlrKzAfEhywkkeAJwyWysmsNKzTwJDZgIwF3B4+0O0zqY+j+YBMyGRi1FGlq3FxCrTPiU3LB1344gumD60E278SWcADghcgXumue9hJUU2wqVvxnRU2znud4pzsp7nEQD6WlgakUECC07Ylpvy4/LYn+zjRHh0uSRV4JPIymGWA2YCu21q1ZwSHhkkfx9MNY9h+DxKEjB4BpDaChh8o7jFJE6eB4CERyJSNPhc8b5QlS+slKSYdAzyPIr6PKpyspm8kH5neMlUMKyHy5ZmyRbMh1apDk3wykE6HLO1YhBVCn9mZn+e0BCijbTRr9CAmdgLj1aEvfMKLXay5Bce22W1wPyqYuRm+Pc5JnBJ0dE8wqWvibK7NCYXZd5R5oPHYsCMVRgAry/MIAV3GMLjab3UAdGFQW22PiuQukzX9cJEOLRvkbUhPOpYwSTAXFALK2AGwLjfAnfuA9JzLTwfpHkkEp2GaFpeLkWln4mkXLNa58tRgk7UZ0E50H4APh6zgl+FgEnU7ZJN05f4IEfPx4Qxf54+J9CuYmD3eNWSh43Xqn8hfzlJXtkAoV/61vtVr1meUCWcJDm/NKUZkuyylMuwXmp85gOaR1nzrPLqO8H4K/2YdE7ddoTS5sBg7XlHNY+SrBAe7WkercAgod4XpiXA5YnJR42T+BgsC4/6gZEmmkdLPWvEjk5OX/MIoMtFxgd7w/ElbTjLwHMh+nwEteDk80gkKg059c5xBhnVklBu86i9rvI3GLLrrtAdXUYBN7yF47mDG6tTSo8CATPZaR5TbYyPSaYWDMdg3siYJux8qZ5vWBNX0Z8Hruwb/PvKgcbRiLzrGrLNpuZR/Tu2mkeXLFvSrvkkGWcbcowGhEeXS3tOodflPV8PLK+/GLj41+KdC3OFGWFsCI9/qh9voyEJjRpxa2l37CEpNI82sWq2zu8HtC0Jr02H8Wk1j2H4PJqbrYGF56dY6h8AeH3WBaru+aFpeRgkyJIEjH0QuOhegwbDNFurfpPPI0H4MdA8qjR9Br5SAXKk4/wdPfyTj3Jst6Z5BIpy0rjrnyqJ2ITLg/kik48wrC/Vxgt8zSCFwGgiqPG+6kOupZkJi+NNqDV9O2oWtYEkuyz1gUEOmv/TG5IVyw0PbuBy8J45H2QsrJ8KDLkVwvoZSXutom+2zs3kB9O84R3M3W6ISvPoC0ZbP4XLgVbOp9NiQPQ1jyWXAz3sBY1YwkDgR49LVD/9msfGc7i67ALT6n2QcffYHqE7TAUfCcu9Y7HP1860DSX1TPvb/FnPywrN3xusJiUDGHKbeucFFcA1f/H/ff6Mpf4ZYtnnkTSPRKLSkB6Cl5anXrmyi9vc8TqEmTuA2m1Arv/rnCnUgmqfR3OzdcfWLZCO06blwiajA5Dbyz8xGDbma1yXOFyU6tKWeWHUY+8wnvYsVHi0k5vNQHiMgTnHJUuWUuswSQ75qJI1Lhs84dHWeYYEzERf8zi+D38NDp5VwhRJUpx7Y7T1/5MqgCufsl6fCQwSfI5oHq1qxKPwHHsMFj4or1X99EFSPZOd8sxTU10zuBA3j+wSukNA8wgAh0STdTfg1dwmkXRCcIXOTz7I6Niq4YNH29fyWiC/v//v89aWDVUjoHnM7xe6LTA3kNmaSEgYC5qt+QEzSs2jReGxyyggpyvQpntwk0rzqHynBITHzNQkHGDGvns+yGDhrjGb3QW4eTPQ+2rjco5qHhlw1dNA2c1Aryt1S5WfedS8TzxM+skTgNq31kxYNoVH5W2+fnhnZYWW61NhI9WPbNVsDTlEcErxJIWUCT1O9XALdk4bMBOhScfgI9Dj5guJVtaWD6LUPK78GVIlv9XgPNzi6U4s4JzPo8VzjYZwkGwgPGreSy9TC49wm6cu07vvZoJ0r/xMFLRugfRUg7nhZy8Bk9eqNrXJUPdJSHiUQ/v47PVlyGzRsJ1nXhZwtTJFWy/v2Z20MrR/gTGXzNZEQqJYQ5g3Qaiim60Kj5yXRinYqdI8mPo8AsluGdtZdzxbX6FbzhGzdXC1FpO6nNY89roSqHzQ0Kx4ANk4YJTkWld4NPY342m5Sjpo27GXqkdpzlbl8wx3UBVwowjBYsAMk2Sc06yrnuLx/w7UwqtPb7nJjd5S/caiZrY2eI917okt4RESt756uGxo98xRR1vbxJVkwxc3GsJjhkHzodp91TiYJBC8pfcumryjHreMt+8YiV4ddDSPk9cAF4wG0tVm7bbp6j6JCY+hz2BhtiLoLqSvkuFYahves5ueG0yLFiQ4N5DmkUhEFFFoPNOUahK0/BXHmVT1xnYB35rUJBfenD0CmSNv1S3lgxx+wEywLyYvvS9CATMmk5eh8GNTePTxfI60g6QTS4qpUhJJXG2CMHbcKCRBzaPHvwrLvpYDQtw5Utz+cwo8ZnyzteY8G/ijUZ5SzfWOWNyXkfCo8+ydZ3Y0j4qAGWVdcEckWIopA2bsagPdydYF26hoHvVXBQqN0tdqHgXGbb37IXBuLlnSX24w8IGnrV9Tr0hQD89sDSMNvyTZ+8A0bAP646DWukOaRyKhUSzbxPN5VAkqDmgefXqSnWmeRwkpSS50z0vHpYP0HcAdMfUF+m02cJoIZNZQXBeBa6FLqyKdg4yFXK7G1mTAF0GreVTXIYVnVrIzMUiSmPB48ybg4kV4M/+WkI8qWWte5gjeembrU0brDIekAHJoyB86S/3bSBujc4/t+Tzy02bVwx0RzSPgVMCMhevOGGLu86i5xowx9bMj8p7ovduigo/Z8Wk5/O0NCD1fvA9NoxRnETNb6zy72jE2mPyfNI9EIqI0W3O0Cx1aK754LQuPoS9Ny2QdDYZAtHVqUsNLm6S/vJoz0dYGZmul+UiZO2zMYpz2GC+xaIhy4DHxuUpOMhhoc4uBq5cD169Xbzf1eeQMiNp+2BQe1XVoNHKZHWAbq88jGoIqRCb7VkXAkJk452qBsyYr7ZgHzDTuPw0D/zM5QprHLE2aJkOzNX9inDPWRjoaVcBMI/UR0zwCXl+YlgBXUpP3efRBVifUFtHQ6wnzwsKjidk7tRUw8pfKHapiYgEzvHHPKDBN8j9nIh8qhucpqnnUKBNI80gkNAEBSJK5k2CP/MzGH1a/4jgvzcDCVpg6pAj/dZlmMhJY+i4lqaE+A/8fH8zzPH7sKzAuYGS2/sUnQOVvGxpTCI/9foY9HSc1/vYYmJnMMJi87r+sBNnpJj5MJZcDHQept5n4ZnKFbp4PkQ7nk/j3RBswA61QdfXyxohIq9gwWzNYC5hhjKeR9x/fPc9/j3kawrSUJPxqfM+G4grNIzMQHjm+a46gfZ5smK2vG2Ke7oULZwzwQjZfTs4GKrO1XVw2zNZR8Xk0Gk80HzOaJOFimkdBn0erGkrl9k7DdcufYfZ8HkP7x8ngITJvuQ3G1BCNps7zEWK2DgiTpHkkEpGAAOTSScCtfBkta3pCXxpJkrDw0hJMKS9S7zhnnEohYLb298MNzN4N3PhuSLngORhMAA/UX2fYVqPZmrPPkwZkNqQz8Sq+NGWX+lrpmY/1UE6mBlqZyeVFIalihDAxsfPN1lqNm367O8e9ws/zaJgrUgLa9gRmvG3YN11sma1ly64N57T+WA3nMKRLDpZM7IsxvfNDjqno2Q4/D0SWK1xDDDWPdoVHM7/REOHRyGyt8+zZ9h3T+ra57WnqOpYJtRWTgJlwZIOxDwLDbgeG32FczuhjVBttrQ2YERm3A+esNY9r33ldtyOdsUEvHZvmGejZsY1AH3nCI0fbqN2XKpBGyIpiRO9ctR/o/96h7kcMIeGRcJ6A5lFO4k9W4QiPVl6asycMdzOgUXgEgKwCbqLhoGCgeZG9itx+vITYKswCZgL7lZpHSbOmtmUBT88v0Kh/FlB8FfMiq7kfDqI+j65kXfOzl7mge27hDqo2IikZJMtRzCGRxop+T+jXHtktOVoL5T1SCO6nLJmtBa+PWTStdtLl5aQLoCsE2DQza+o7D3dDlgWLQl5OV6FiAZ9H20+WJIUK0OmhHweNhOnzmNYGqFjoH8+MsBAww6DVPAq8J4E6prxsWLdoH7jb9f4GkJUhYKkxM1uH1NuwL01AMDV8hwRS9QD6rkEkPBIJSWBic7lxEzdJrIHvzMwdxnU7KjwqzNYG6OV5VDpka1c9CcEsVU9gu9LnUXaBqQQji5OtFTOenWADhU/lCrkqZDdXG2dB85js5u8zTjQe5qBqxxle4ulH9WHgCHza68ATrHSulWEQjMCa2VzMroM2SjWrALj5H8Ccj0PLhhF1yz9OqxWTUZjdwrrZuoVxflfAf68qinOt1ctDew266qcGAxCecKBwGzIkRTxVj4/JmoAZCz6PHQYAg2/UrVvfbC1gzjZ690X8TEU0j6oxuKG9lm3N6zYSHu2arbX9iCGx7wGReCg0j9OHcYRH5UCqNV2ZaQOsvDSFQwx3q8zWwfp5+fX4qXo8yY2Dg7nmUVL/H7K/4Xjvec02RXnLmhoLk6mN5Ngq0w33uvG0zuKpejxuvi+h4frYYed5tO7zKEmy5Sjm0yF+igKTiR15IiRVj6jwaFHzKMn+FZ8y8oE2PUL3abnhLbF+8NA8ax4X8Mi1/WBZ89jCPBitJD8Li6/oHWjYWv1KlO/ukFuBTiNMDgijrS4XNVRh9FHh8rvLBBg8Qx00qDk21eNWj3FWNI9GfwMGQr+I8MgPIgNgHBAUwKrmMdCeiPBo9g7ptaFE16+cNI9EIhL0eUyCZKZBsWwmtPDS5PcFZmwEymfqFklymQdweJnMnZZcSY2CRvhm64btSrO1LGvM1hYFPCuaGDs+j/2nYK13CGafu4V7Vp3acMxGIe3o389kN/+a1hsGzIRrtrYuPBbnZyHDaDUMIOTehWoeDbQdwW027pHm/au9SMxUa6p5NPoImPEOMPIexT7OuWR2FOsHt22NYCP70LF1CyCDvwyiLgKax85tWiIjxYGk0Mrr1b/G+EOQMdvP8SNSNZDesBSp8joVDVcXdCUBSQrhseelQMGFiv6qNXrXD++EkvaKj0WhPI+CQp4els3WDW1c8nugXR9g1HzzNngCnmFQX8BsLaJ5NFqFRzBVD2keiWZFIOhDT9hRPviaVQJMsfrS5PcF8vgrcPCTWBto0AZMVe9QaE25aWnUFevW79+uMVs3TDZhma2taGLsDEbuZMw+PxNrfcO4p3VxCefeOmC2nju+F9I8gqYrq9gwW7vdLpRfYKLFUgiljAGntbkZwzBbG6I5Zs7FPXQKajBbfs7oPialAtmKSGrec2tRSD/AWuOZlCmBCtU7A+4TKRnAre+LV5qSaV7GKd8y5f2UZIF32V67143sq24nwE/u1PTHrdY8SrL6Y1Mj7GWkJOH31w5o3CZkttZ5L0U+lEKO19nO+3vgdH/gY7qAuwFPwOPldtTuE9I8KupObS3ehhI9zSP5PBIJiULzyH0plNvKbgJ6XQVc+ZRY3XZems58ExFftDIwk47/PXDnvsYdbRsn4vOimkezATHgLxqcbJRm6wi+rmF+yfJvi2JjWhtg4nMcjZXe/WRI1vFHnTi4CLJekEy4Y6qtpccMVsMIkK1OS3OKWTBpBbChFeX6l132R/PjzIRos48ApbDEE4QtCum/PH89Vqdew2+rZV7j39kcNxk9BNZnNn2gRN8b7fUyc0GxKRzkpCvOSdk3XvsefTM13zSsGDGFzNZKgdlA82g12tpJNxWuadnI57HhbxGlh9Ln0SzARtfnUSejBWkeiYRE4fPIfciVA2dSCnDVU0Dvq8TqtvPSpOdxN/MjwTlma8gYW5LnF97ScoC7vvQHBii+Jrnr9HIHOauaR2UdYQbM3LRJv2y4wqNZVH3FQqBnlTXNo0sv0MKl0ZI46fMoKNT0uETTpslkf81fgn+Wd8kONVsrfV0BfpopkfQgSiSZL4T0qzY/1lTzaOK7avbcWhSEGaTGbyftOdlNCi+U6Nrkvpqdx9iHGurRPKOG73IY0dZ6/oDa+yW71Sl0RIJElCZUK6l6RLdr0RUeXfwyNq0nofUbaR4b/haJ1Fe+QyEuEoKaR92FGEjzSCQiQc2jTv61sCZ4514aUaPuRT1yUTOkqHFDi9b+wAAFIev0XrLE/y9AUPOo0//AgBrI3ycH1jpWTgBWg1o0Z5jTTb+ozXty22j/IDr0Ao7/GG/QNfQnUtMiWXTy4fgkiTDo58CgG9TbRAQKTzowap6iSdk452X3cUDrTsGfVaXtcFW55l4o8jYCAM6eDK3HqvAYzhq8ptHW2jyVWuFRZ4IPYDH4i0Fq1DaHCI+Cvo43vA10G9v4W+j6mGi1zfJhXnhTQzmNFi5Cmkfd6x6ieeSYrXW1gw3blStWiVy7LqMUVRhoHi1HW+vUJXLNhtym/m1Z+9zwd2sBDbdS86hNixSyPKFF4ZE0j0RCEvR5FDBbW8XusZzj+JGnods6ZqfDJXPK5hYH/zyrXQpLu4yaaKqegI8LT/NoOWBG24bBhGXzus75aTd89F9j0LEVz/GcJ9QxgzIKGEOSS0Z2GkeYM9JeWpl0x/93yEeAsMClFYwNl2rUhPdIEnoXadqtP6P+fY4jPKZkhWyqN0oRZWO1nMZjLfo8GmlSHFg2UKWL0z6rBgFxKtr3Bzr9pPF3ONcnQP2PYuVU754k8L45oXk00MrJbsPoau6xSh9Rs3t63Sp/sv7GSvTb0sOuz6OCH10aoU370SPk88gZxw2DYRpQvkOGq/kYQD6PRLPCis+jVey+NBwNgajZWre/5TNR33cK/lz/UxxDWugxdszWwf76fzNFIvKwU/UYXfcw7kkLj0BglO5EYHw/uUK7JEM/AXo0AmZYqMDqO69fnNuOyeQjaLY2XHfdjo9kALPJ0SzlkjZAJEwYpIZE4IDqHo+Y6w+KE0U5DggtsWfybJmsstTYruId0Y4Npu1aQO+d42oeFWZrxgxcQRr6ktkeuGwpcM2z5v3rNkasX4BaiNU7Rqiu0D492e//oebc3Y0bVPOAxH9HjDSjyn0X3cvvXwAjzaPoOBXHmkcbyd0IwgSlz6NIrj8r2H1pXEmA96xq07xLijkFBQXKhjrlSx/Bgq2vQYZPs1NS12VmttYz+9lJcRFA6/NoNOCHOxhxnd45fQ/pk4V2L3/Cn7tNkgwjQy2hvSaiApfSzMRYqM+iURuAWgPSaQRQOFS9n6d55AiPhvklwxEeLfs8CviJhQGD1PghoazPbBUVLcp+u5Phkz2Qfef0yzu2FrhFs7VtzaPOu8D1eVQIbSEaVJ16+v3MuX5d+yLw5i+BK//H/BjVdnHNoy+lFXb5FCZmZXJ7t96a40b+iMoPl7uArEJgzQx+P5XvkEerXOAfEoJunsfYQ8Ij4TyKFWac8HdSY1fzGPqo9ytoHVqON2AZ9FdumNBCEmLrma3N8jxq2lTneQxX86hoo/s4vwmv68X89p1AyJxsod0+E8NoRw87wqMEZHTwt+tO9U8SRhoo7jOleB4nrw31eRL0eYyY5tE02tpKwIwTwiMQVEKH48qhFNrdyThx/Wb8/o+Poqf0NSa63wktb+e9kN2hz4OVgJkw8jzqanx5mkelcHP+R4OPMCfGBk7dPcb5/+keIqJ5NP5w9C80oHMdXMn8NkRS9Zj1EVBrHkM+xsLUPGrdXGJA7HWfROJhFm0djqBi91heagluXXYDfCSNFkijeQzmedQbELWTMSfPo4iTtijuZODCmxtTm0TCDKKXTkdVxol2wzBba/sl6gfn9gD3/Bu46wu/4GekeeQer5hMeM7yGZxUIFEVHsM0Wzvu8yg1RvQr75l2mUQAuOJJ/YqU/XYlI7N9N1x1y68xpl8nvQMUfwo+W7zrLmt8HiOmedTTynE0j8rzOX9arB67iIwFIcfotKsnIHPq9bhk9Ye9ym1BZ34KufYGAqrRuSjfIe3HWGqW/nF6dSg5L+hrG0FIeCScJxA56kriv1xmZmudpN7+Y53zeeQLivbN7CxEu8AzW+scrOszpjhg0PUCy5opO2QQTx6yLxKaR96gG4bZWoWJf5YwWs2joM8j4Df7BXwDDX0eOX3qOBjoPNK/2giPqj/40wFd9UzjNs6EE7eaR9UE74zw2C2vZWhbvPe69Bogv79uTUEaPhR6tc9EVoqOBrPDQMWhgvkZeB+qKp9HyfyaOO7z6ALKblb/VqIdc1X12OuKpkJ+3aLHqDaLm60v7ZOvn7HCbUPzKJpiB1ALfsp3MaMDMPwO/eOUjPtN6HKfQKiwHwPIbE04j0+xwoydgJnrVgEP66yEYdvnkZeHUfBYQc0Jk1wAazh3SdIZ2AQ1cLyACVeyP0L4sYGh+7gd0vphGqBsv/NI4It3xI/Vr1Tnb+VmmzOTUz6PWuwKXKKBEwFkFzDlb/r7swqAa5/3/33qO39wA0coMRQeIxltHWXNY2Wvdrh8bGBMUGoedVLl6D1XSjOg6hw5gmG/nwH9pwR/cmtMzgTOHlNv4wZhaLRlpgn/7QqPBmbrsYv9Qsf7f24Uon6xFzh52G+B0AuYcUJ6jMbyhJx+ts1IwY57LwL+u2GDch5wecQ0j4ZphgzOReNfG6TmZXHNY+vOQO17wELNakikeSScYP/+/Rg5ciSKi4tRWlqK1atXx7ZDXmW0tQ0zcEY7oPt4nZ0R1jzaMFv3ap/hb8KlMU3xTF6i5tsfjwIAuuYqovRk2Z+cduD1QL/Jhn2yjJk2J9w6LQfM2F1aMUpmay1eiz6PVii7UTexd8QCZsyONQ2YMUjkXHGf5e5MKS9CemCNaaFnVeeaM51E1zytYr8poeZmJeMfBq5+OvQ4nvZaW49ZknBHNI+a9iWpcWWUgPCYnge041h6HPeBjoLwqFO+RbIycEUxnrqTxeYnI8uG0YeRsqyNZU8N4SkXogxpHhMAt9uNJUuWoG/fvjh48CAGDBiAcePGIS0tzfzgSBBM1aMzAYWjHQon2jqkLmfM1mtvGYoTZ+ohP6JJxyFzBjaRAVFB+yzOcmOXPAycOgLsetawX7YFMMvJyMGffIX8puxOUsr2bPhT6bWvWUZQGKtma4eohwtt0pMBXvO2llpswOwZMNPA6N37W3f6tSkiZBUAP3zdUIeO8MGzKGjLK1FqHlVleO+K9kNHs3vQ9cC/1Wtp+3pOgHzwA05/NNcjYknC9czWbvU2s/HQ9No41C/RY1TbdZ4FvWvmaQFU/tb/4ZCmWINeN5Wcgc+jaB+1xymfeSdMzqU6wYNRhDSPCUC7du3Qt29fAEBeXh5ycnJw9OjR2HUoGDCjM7CnZNivOyY+j8Ztul0yWqV5QgcybW43vTZV+zUoTc9KIVbEFGjoo2WgAdSbkK3CnYyc8nnUqyNMzWNaW+NlHAH+dbWaqsch3C43lk8bxN8ZzgozkqReMzpkv4nwqBvUIGjCblviT4PSeCD3T+uaR513grddxC9YUcZ383uQr34GGDjdv6FgiOJQzdjggB8oF7OAvMCzaCq82nwvy2fy359omK2N3rOyGf4AQeV560VbG/k1WjFbA8B1q4ExD6h91c+HGSl9z7+BrI7h1eEAcSU8Pvjgg5AkCbNnz9Yt4/V6MW/ePHTq1Ampqano0qUL7r//fjDFS1xUVARJkkL+1dbWBsssXLgwZH+PHjp+dmHw7rvvoqqqCvn5+ZAkCWvXruWWW7p0KYqKipCSkoKysjJs27bNVns7d+6E1+tFx44xfLiCqXp0Bva+1f6lq356v0Eljffzx2FzGzc76vMYZtSfFl4uNW0dumZrgclOWb+QdjCKmkezOkW0CLbbCcfnkTNR5PW23gerPo8OkZuZipL8TP7OcMzWkIDZHwL3fMPfbZqqR+KXFXm2cnsBP18fGmTCa0uvPt33Sc8PmCc8CvgMK8zgclZ7v7WhvBaoeQWoVrgPWTF3MogH52jR5h/VthcUHi1olkW7MnktMGaRzvtjR3gUCZixKIRLGj9EoYAZo30m59LtYv/zIElA8WVAbm9rSe15JLc0LxMF4sZsvX37dvzpT39CaalBpC2Ahx56CMuWLcOf//xnlJSUYMeOHZg2bRoyMzNx2223Bevyehtf6j179uCnP/0prr76alVdJSUlWL9+ffC32218OTZv3ozBgwcjKUktFH300UfIzs5Gbm5uyDGnTp1Cnz59MH36dFxxxRXceleuXIk5c+bg8ccfR1lZGZYsWYIxY8Zg7969aNu2LQCgb9++qK8PnaD+/ve/Iz/fv9TZ0aNHMWXKFDz5pEGqimhQfJnf/NeqE39/UioweY1wdaldhgLBj9lI+zzyjhUcoFR+XhrNY7AtnTbPHNepVOnEbnES7m6QQ02LanK2oxWxabZ2JGBGx8/LDnY/TgxT9URO82j4HIRjtpYk/+Sq56tlGjCjF7gh8GxdMNpvalT1Xyf4SldLLuDzqNouYrbmaR4VAmbgXsguoNNwzbGad8HsHbMS7KbXDvfD00B4/MldwL63/B/3dt6DLhcZ9MvG+GKmRdXWK4JK8ygaMGNg2dAe364PcIDjtgAA1/wlvByecUZcCI8nT55EdXU1nnzySfz61782LPuPf/wDl112GcaP9wdUFBUV4cUXX1Rp6tq0aaM65sEHH0SXLl0wYoQ6zYnb7UZenoFpRoHP50NtbS26du2KFStWwNUQHLF3716MGjUKc+bMwV133RVyXGVlJSorKw3rfvjhh3HDDTdg2rRpAIDHH38cr776Kp5++mnMnevXutXV1RnWcfbsWUyYMAFz587FkCFDDMtGnLY9NeuaarH6wvPMvxYRzvPIwY7mUTtBmPk85uj42ulqHg0Eg5s2+fe3taBJj7TmMXDPHUsR5FBkaIgmwWZ/jHweIzlZGE3EYTnpm/TZ0gozFtP2BI5VPuO6mkeL0da64xLv48eia4jo2vGSZB5tbVfzqHoXlGOHxueR944XlgNzvwaSM6wnoU7n5CVVd0zxp+i4K6J51BGWdevUCo8ibkpG0daKfZ1HAte+ADwQWLee90wlhuAIxInZura2FuPHj0dFRYVp2SFDhmDDhg349NNPAQAffPABNm3apCugnTt3Ds899xymT58OSXPjPvvsM+Tn56Nz586orq7G119/rduuLMt47bXXsGvXLkyZMgU+nw/79u3DqFGjMGHCBK7gKMK5c+ewc+dO1bnLsoyKigps2bJFqA7GGKZOnYpRo0Zh8mTjKNylS5eiuLgYgwbp+ElFA6sCYDhfmgG4ApHoIGZD86hNBGwWbZ2SCdzxOWedVx0hyUiDk9rKXHA0inp2ILUKAPV6rkb+S5f90f931SP6/RMl3IAZoWeT5/NoZLaOpObR4F6Fq3kMMO0Nv89W8WWK/dp2Bc2yIs9WMKiDp7mH+h7ppurRuY+dLwImPA7c+K56u/J5u/AW/8pLHcv0ywS3KTSZhpG3Ws2j0XPGHNI8cvylzXweUzIRkmZMBDM/YZXiOEI+jyKo0ufoaB6tRFtb1SgnEDHXPK5YsQLvv/8+tm/fLlR+7ty5OH78OHr06AGXywWv14tFixahupqfymLt2rX44YcfMHXqVNX2srIyLF++HN27d8eBAwdw3333Yfjw4dizZw/S07WLmPvJz8/HW2+9heHDh+O6667Dli1bUFFRgWXLllk6ZyVHjhyB1+sNMXnn5ubik08+Eapj8+bNWLlyJUpLS4M+lc8++yx69w71PamtrUVtbS2OHz+OzEwdX6lIE46pIRaaR1FhStYMMlyfLU2bP1F8dLRs448G/EHxEaObz9Cg73ZS7YQzIPPI769er1k3YEbyp6Epudxvqvzf26y3FU7frfow6RGPmsdwfR4DFJb7c9O9/QCAv/m3aTVnhoEEOtpz3aZ5mkedCdxqwIwkAX0ncXYo+jh2sXkfg4cpBTSDZ0erHY+Y2VpRL7OoeVRXJN6mnKSOYjarL5bCo+rDQ9Tn0UjzaPBRYPcDuIkQU+Fx//79mDVrFtatW4eUFJOktA2sWrUKzz//PF544QWUlJSgrq4Os2fPRn5+PmpqQldreOqpp1BZWRn0Cwyg1FSWlpairKwMhYWFWLVqFa6//nrd9gsKCvDss89ixIgR6Ny5M5566qkQjWa0GTZsGHw+m4NNNOh9DbB7lWKDwPXSTVhrk3B8HoUHO63mkRcwo6hrxsZQ52kjzaModjRO4WoetQPlJQ8bf7Fr2/Voz9tCe6q6o6F55GB1eUKnMNQ8GgiPg2/0v5P154DznJxxZmOaWdSpnhAjdH0b2nbpmK2VyzRaTdWjh4jF08zn0bBNzYef6TvG6VBOd+DIXuPD9DSPsmb8sZSKKd5S9TiledSLtjbqh4nm0SmrTRMgpmbrnTt34vDhw+jfvz/cbjfcbjc2btyIRx55BG63WxX0EuDOO+/E3Llzce2116J3796YPHkybr/9dixeHPq1+NVXX2H9+vX4+c9/btqXrKwsdOvWDZ9//rlhuUOHDmHGjBmoqqrC6dOncfvtt4ufMIecnBy4XC4cOnQopB1Rf8y458ongdELGn/HRPMY5WhrSTaPtubVm5Sq/m1HA2HHZ1HZl8Jh1o8PmWAk/rlql9rSvbaB+vTukVPLE2owutc9L/X/Xz4zdF+M8jzaFh7H/Qa4c59f283FTHi0sMKMrn+qDudO+v/nBpwB6DK68W+n/HMtCkh/G/qS/w+fTgCOFivmzU4/4b/3te8B7fqKt8M7p6JhQGZHoNtYC/WYISR526jbQHvMq8spn0ejfpglw3dC0dFEiKnmcfTo0di9e7dq27Rp09CjRw/cfffdwaAUJadPn4asMZm4XC6u5u2ZZ55B27Ztg8E1Rpw8eRL79u0z9Bk8cuQIRo8ejZ49e2L16tX49NNPMXLkSCQnJ+N3v/udaRs8PB4PBgwYgA0bNmDChAkA/ME5GzZswMyZnEmqqRJOOhW9lB1W4E6kgnW1aC1WLiTamif0mpieQzSPNhDSPBr4PPa+yt+3/H72+yBJ4Jqqel0FbH8K2L81sMN+G42V6/zNodtY4MCHwLDZin4qDzd4Nq/8H38kZfsBdjoZGcIxW8su/QnX7D0zXdta8VulKRQwpZ/6rqGsUvOo2N9hkP89cSUBLbL5dVjWPFoTHo+17GLtOO0KMzyhf84nfpeVgjLga46/uyQJ3BcdzWOA/H7A7XvM+6tsx+wcha6Bk2brcOYSxXVPbWVd82j4kSRwfxKImAqP6enp6NWrl2pbWloasrOzg9sfe+wxrFmzBhs2bAAAVFVVYdGiRSgoKEBJSQl27dqFhx9+GNOnT1fV4/P58Mwzz6CmpoabgueOO+5AVVUVCgsL8e2332LBggVwuVyYNInnD+Ovr7KyEoWFhVi5ciXcbjeKi4uxbt06jBo1Cu3bt+dqIU+ePKnSZn755Zeoq6tD69atUVBQAACYM2cOampqMHDgQAwePBhLlizBqVOngtHXCUE42iGtOdgOPLO1yMDR++pGjZNpGwZm60C/zQa+HpcAX21unBTt+M3Y8XXT3p/eV1mvQ10h39wjy8DQ24AVW0Pb5SKQ1NmKGSunGzBphbkZnYc7Geg42Lh+bp1R0DxOfB54635/xOd7j/u3heXzyEP57FrQPCZnANPf9L+DIh82p474/5d1UvW43MCcj/25NbWael55IawJQMHHT9gyoHnvec9Zep5/aVajenO6A9/uMmjGRHgURS9PJ5cIaR4tm5Qtah5TswTbMPg4ddpXvAkR84AZM44cOYJ9+/YFfz/66KOYN28ebrnlFhw+fBj5+fm48cYbMX/+fNVx69evx9dffx0iVAb45ptvMGnSJHz//fdo06YNhg0bhq1bt4ak+QkgyzIeeOABDB8+HB5P46Dcp08frF+/Xve4HTt24KKLLgr+njNnDgCgpqYGy5cvBwBMnDgR3333HebPn4+DBw+ib9++eOONN7h5I5suYUygkTJbi2Tpr3okjDyPvFQ9JlqywTOA9FygoNz/247waMfvxumBT6slUQ2yDkTPq9qy8GEiyZp+OeTzWPkb4PW7gIvuBd5epG3UXp0iBK5lz0v8/+pebNwntE63nubR5DqYJgnXPPsFF/Lr6VsN1D0PXFgLbF3q3xYQHvV8HgH/xG+EtvzIe4zL2yVwXm2Lxfuj5/Moou0buxhISsH9W89jXtLznDoiELDhiGtAuMKjBNNcsiLY0TwatWc09lDATHR55513VL8XLlyIhQsXBn+np6djyZIlWLJkiWE9F198sWrVGS0rVqyw3Lef/vSn3O39+umb90aOHGnYjwAzZ85MLDO1lnCEEyd82niaR12thbJtK1GHWudpk+UJedfE5QZ6XanYEKEBKCRVT5gCDjd/o57w6PDXupWAmUgty1Z2oz9ivGXbUOExoppHrblY49NlF7Mo1JBJ1EgjY3D+lywBBkz1R+cHhMdzJ/z/6/k8CqEof/M/gNwS4+JCEz2nTEoGcO9B82ttOdpapz8tWgNVf8DOf/zBvJ1wNI9KzLTFQr6GJu463GMU5+LyAN6zxvUK9UNRZ0qWDeGRNI8BmtfZErEjnAnUiRdUG9Usaoq20p5QtLXFQTRaX68R0TzqCBBG0YvC2AyYCTlP7WQQxnPasq1eo/brNEMrhFgVHvUeL9PraKKx1bpw6OH2+F0BXG5/vk9POnBZgxDpPacoZzHhuSp7gICOJFsnSb8ISanWPkpEonJNBD+fbjCJol4zbagoptcvUj6Pir/1nuVwgi/taB6N2nfcTSS+iTvNI5GohOGDFFYqlgb6TQbO/+gPdjh9NHT5MF2saB6NzNaBeqwOok1UeAxxHtcRmvUGf0tCs4VrGuKrp2m/qaXa0E7syt/KQBVddKVHa/2wq3lU0q8a6DOpUZt6+vvGfTndLfbH4gfKkJnAmR+AHkbBlU59AAtoHrX3pZfaB1lfeFS007YHMOVlgdVfTHDinQg3VY/uMpRKrPo8Omy2JuGRICKAY2Zrm/XILuDCm220bWHCMFrbOrjCjMVzaTKaR54ZXEdI5ArVuh0zb9qSdthE8xgJLWE0AmaCbSl+660tL0LYKY9sChxKM/zQWcCRT4FRvzJfzi+kHosZGpJSgTFaX1V9RFyRVIj4PKoaUGgef/YSUKhecpbpGQ21z3fnEfxyVnDC5zHcgBk7Cx+Y1SkaMKM63uAjKcS8Tz6PBBE+sfZ5dKJtM4yirbkBMyJYHIDcYsn2DZcndASt5lGnLcd9Hk0IWRklys+T02iFNGW+yVZF4VQcxrGw7ovGI7cEmPGOvWNFzebRwjDFCwel8HjB6JDduprHSGjO4yFgRsgFQ+A5U/pNpmSpXSP0O6LzN0jzSBARJ9Y+j060baWsVvMYHHQsDqJWJt7b6sRzUmoJ97ryAnCE0uHoPRcWztuKoBITp/YoBswcP9D4t8izYCnPo00XDqcCN6wQiQ9Op8YwkbpMrhkTSaDtFE5rHoWzVxhp9WyS2RHI6w0kZwKeNOCMxZWhrJitKdqaIGKMIwEWdtu2OWFq8xwGJgOrk1pme/H2W8fQTBlaIXS/2B3/GLDiWmBithbV3Fohko+sVvPYpptiXzgNh9tp5fExmEQtuUZYp6yzTnJyPaw+5yaCh5DPo1PESvOovAZ2Fj7gIbuAGe82ftyGa7ZWBag5JOA2ESjamogO4QyesTRbW0Frplb+DpyPVd+fnpcBP7kLqP6rM33UI9LR1qp9VvJ2Wky/YVrWIGBm4nOCuRGtEkWfxy6jgaueAW59X7ACmyvMmOGE2Tqs9iNrtu7ZLsPaAZkdQrddbOBjaTvaOk6FRzs+j776xr+dNAnLcmN/KGDGNqR5JKKDY2brOBYejQJmuGs1C5yLLAOj7nWgc1rixefRgfup6rtVs7WifbN1g+0SyWdWu4SkJAG9rnCg4nCFRwv3JBJEWPNomYx8YMrf/KvtBBgy07+O9zuLQ8vbNlvHq8+jEsH7oVw3XESrZ+sjxeqzQT6PAUh4JKJELE1oUcIoYCYwEIazLmskiWa0dUwDZgw0j/EgZIhy0yZg39tA2U3h1WPF59HSdVZM9m6BZPxOE2HNoy06j+RstOfzqy88xqvmUdEvUe1+pDSPSkSul+GKVIrfzSzaOo5mLyKhCUvzGCeDvxlGATM8n8dwufIp5+qKxKSja7a2qH210k5YATORes4iUG9eb/8a4WH7WTmU51GL2+Nf2rPyt0BL/tKtESXeNI962MxzGl2ztRN5HhX9FfUrVgqPQs+jDWHNUbN1w7vYosEf9oIKa3Vfv95a+RhDwiMRHZxK1RPPaNeyVkbCBs1QDk5kva8yLyNKRHweBdKJmLYrcr0cCphx6hpc9kdNE3EsvOgRbrQ1AAyoAcpmONIdy8Rbqh49dIVHM59HwTyPTuB0wIxwOjGveZlwsXy9BMzWs3cDsz4Ecrpaq7rjIIt9iS1NZFYmmjyWX1KdgJl4Tn9gZCpjPLN1DCa1/jX+/39yh3q706l6jKKt9czZdgknSXgk7ke/auBX3ykbcabeSKD7PsVxn0XQ+h87U6lD9Sir1Hl27WoeI5Hn0YkoYuU9SBJ0Y/BaTKNjZ26IRJJwTxrQqtB6X5oYJDwSUcLBHGnxipGpLBa57nhU/QG459/+ZRqVOC3ISrKY2TrWPo+R0DwCEYrajgQORFvH4/vZZDSPetfOWBD6w7X9deqL0zyPKs2j4DrlvjjUPFK0dZA4fOuJhMSxBLtNVfMYJ8KjJAHJLTnbo2i2dnoyDyvaWrWz8c82PcPpkabaOBZelMzYaO84x6NxHSAimsdIYM9sPaBQJwF8NH2XLdWhFB4FNY9WzdZ28tyKPBtKIdZQ89i8hMc4fOuJhCQsn8d4HvwVGPnyxbO5HYjApKONtlbuclrbZ0VLZmDWU/blpk1A/RlgsYUk7foVO1BHhFA+l/l9G//mRlvr1BGPwmOT0TzaEx6Fcqg6Rcw0j/XmZQBg2hvAd58ARcNsdEvRr0E/B/r9LLTM2eMGxyvuQzy+BxGENI9ElGgGZmuj/IXcySCOJrVIpOqxmgZDpF6zOjxpJmW1fVL61irTbrj5Glo7NJWPHyUezrl3H+f/v2Wuens8TppNJjeszjuSkmnvuHgNmLHj8ygqPBaWAwOnWe+Tlp5VoXlTAeDHH/SPUQrrzWyFmTh864mEpHulfz1R0YgyvRVm4hkjbUe8mK316D4OeHtRqGBgG0GztVMmsUuWAGdPAFkFjdu7VQKfvu7Pr/fFO/5tRgEFERMy4lh40QrnFfcBBz7gpxnJLQFmfQCktVVvj8f3s8loHnWu3dBZwLe7gF46GRWamvCoDH4R1jwqx8woWG70rEPnT+kfo1qzu3mJU83rbInYkZIB3LXP3gumirZ2rkuOo/Kz0uyLd+Exrxdw2y7nhMcQn0fBvHQtsoHT3ys0AIITP0/zMPE54IevgP3vNQqPWr8k1YQRx0JGpNBOmMNmG5dvVRS6LR4nTdVSofF8X3X6lpIJTF5jcFg0hUcHTOH1Zxv/FvV59FmMtg6bMKO1IxHpHsfE4ScjkbC4ksQH8nhdicUIQ5/HBuFR+dXtaRH5PlmhdWdzs68e3FQ9OhgJldP/Dgy+EZj4vL1+KHG5gewu6nuRol2TOAoa7g5NK3+bZeJx0rS0frponc5Uo67TZqUiS386hRPmWK9CeBStT9Rs7RThpvpxwt90wuP+/8c+FH5dESYOPxkJAhqztXKgjGPVo1G0dSBiz5MGXP1nvzBp5tfUlDGcFA0+DHIuAMb9xunONP6ZrBEedZ8zB5i5A/hmO9D7amfrdRQH3qd41Dyqnqs41jzaFfb0jouEIO/E/VVqHkXfM1WqnmjcQ5N3IYnzse90wEzfSUDxpfY/4qNIE1HpEEQTQDlwh5hHFWbrkglAryui0qXoYaJ5zMjnHxYNk6KyjeR0g3IOD4c5XYG+16lXGoo3+l7n/79jmf064lLzGONk/KLYFh4153RBBXDXl5E5V6eFR1FKr/H/72TaLENMrl1KFueQCERbNwHBESDNI0E4h9LMkp6n2RnHGtNIEJjEZrzjD2RRXo+ouyQYCY/N3Odx1HygYAhQNNR+HXGpeUz0e6k5v5Z5QAud3I/hwou8t0r9GevHdB8H3Ph/fteTZyP4sd3nOuDwP4FOPzEu156TmD3qqXri57mOw7eeIJooJw83/p3aSr3PF+cBM+GS1kazoWGQ46W+0F22MEIoJ65oah6bAm4P0GNceHVEIrdguEQkVU8Ulyc0PU6brDr8roRw8SLgn2uAITPDr8t7zvoxkgS0K234EcGP78uXGe+/fh3w/p/9mQi0RDtgJo4+ikh4JJoW8ZxsWyk8xuvyhJFi6Gxg+/8AP/7H/9tokFMGDUVjMDx3svHvJI1JKJI+j82FuNQ8RsLnMQJjT9eL/f8rU0wJdcVCgJpdhsx0RnAE7Jmt44WOg/3/eEQ92jp+xqg4fOsJAmiSZt6TB/X3JbrwmNzSnxpn+fiGDQaDXKtCoOxmvxYwGgPuWYXwGOJ/2ATzicYbcenz2ESShGd1BO74nJMFwCLxfI6APc1jU0D57MuUJJwg4pg4FiqNBo/mJpiYTWaVD0anHwBw7oT+vuae59EJ4l14dOy+Ruj5aKl1+RAgJN1NnD+7rWysO90UkCSgeII/N22bHtFpL05oZjMaQUSQy5cBub2A6r82bqu4D8jsCFz0y9j1q7mj1Dwa0dwEfKeIS7O1Ms9j/Ey4juFJA0onxroX4gy5FSifCUx7PdY9cZ5r/gxMfSVKWRXi51mm0ZJoWsSzz2N+P+DmzUDXnzZuGzYbuH2P3zzVnIinCVs0n2Y89bkpcPEif97MS34f656E0lTyPIbD8F80/h3vz66nBTBmEVA4JNY9IRwiDj8ZCYJo+sTRZDZ0FvD9Z0Dvazg7KWDGNkNmAhfeHP9m64S9r1HOWkAQCkjzSMQn8axhJHSI08TMqVn+YJ7iS0P3NYfnLJA2qkW283XHo+AIiK2rHladcUCsE6GX3ez/v9yhiGzCnDh6BknzSBBEBIifQc6YZiA8Tn0NeGdx8/K7jYTmMe4+NGKseRyzyL9CUW6v6LfdbImfcZU0j0QTI94GcKIRMgHHJbnFwMRngbbRWuYtDlAJjwk6zcVa8yi7/Em8oxEo0uMS//8Z7SPfVjwTR+MqaR4JgnAepybsSA+WcadNIhyhOZitVcRz3xzgwluA1p2AjhfGuidEAyQ8Ek0LmuzjmAhM2HS/CTs0i4AZBYl+ji430LMq1r2IA+LnPieoPp9o+pDQ0KRpKpMZCaeJiWq97SbyLFolEtpVIr6Jo3GVhEeCICJA/AxyRDOkWWge4zS7ARFB4uc+k/BIEITzNJnJjDSPCUlTWp6QIESJo3GVhEeiiUGTfdMgfgY5Q8hsnZg0B80jma2bD72u9P8/dFZs+6GAAmYIgnCGWKcOsQUJjwlJk3wWrdIczpEAAFz+J38y9nZ9Y92TICQ8Ek0L0hQ1EZpDehQibknU3I5KSPPYfHAlAe37x7oXKprBG0YQRNRpKkIffYwkJs1BeCTNIxFDmsMbRjRFdCd1muybBjSZETGkWQiPBBE76A0jCMIhIqAJibhmkD5GEhLZZV6mqdMs/DqJeIWER6Jp0aoo1j0gRGgqkxmZrROTSGge4+6ZJp9HInZQwAzRNJjyMvCv/wP6Vse6J0RCQcJjYtIMhCnSPBIxhDSPRNOg8whg1K+ahznKCpc+6v//sj/Gth/RJrWV//+UrJh2g4hTIqF5HLPY//+QW52vO2xIeCSiC2keiTiFNEJC9J8C9LoK8LSIdU8ig55GZeprwNuLgIvuDa9+MlsnJpEQHvtMBC4YDbTIdr5uW5DmkYgdJDwSRFMnXgTHaE5gucXAtc87UBEJjwlJpJ7FtJzI1GsHEhiJGEJma4LQhQZngmiSBNwaEhoKmCFiB2keCYJovpDZOjFp3x8YNgfI6hjrnkQOCpghYggJj0R8UjAE+OKd2PaBEg0TRNOlYkGsexBFSHgkogsJj0R8Mmy23/R0wejY9YG+5q3RfgCQ3dXZXJyUJJwgdCDNIxE7SHgk4hN3MlA2I8adoAHZEq4koHZb05rIyGxNNFWa0ntGJBwkPBIE4RxyUzP1k/BINFVIeCRiR1Mb6QkietCXfeyJ9D1o1yey9RNEVKCxioguJDwmAPv378fIkSNRXFyM0tJSrF69OtZdShBoQE54uowGrnwKuGVrrHtCENagj1sihpDZOgFwu91YsmQJ+vbti4MHD2LAgAEYN24c0tLSYt01gohvJAnofVWse0EQYULuF0R0IeExAWjXrh3atWsHAMjLy0NOTg6OHj1KwmO4UKoegiDiFdI8EjGkyc2ODz74ICRJwuzZs3XLeL1ezJs3D506dUJqaiq6dOmC+++/H0wRWblw4UJIkqT616NHD8f7++6776Kqqgr5+fmQJAlr167lllu6dCmKioqQkpKCsrIybNu2zVZ7O3fuhNfrRceOCZwcN1rQ4EwQRNxC4xMRO5qU5nH79u3405/+hNLSUsNyDz30EJYtW4Y///nPKCkpwY4dOzBt2jRkZmbitttuC5YrKSnB+vXrg7/dbuPLsXnzZgwePBhJSUmq7R999BGys7ORm5sbcsypU6fQp08fTJ8+HVdccQW33pUrV2LOnDl4/PHHUVZWhiVLlmDMmDHYu3cv2rZtCwDo27cv6uvrQ479+9//jvz8fADA0aNHMWXKFDz55JOG50GIQoMzQRBNARqriOjSZITHkydPorq6Gk8++SR+/etfG5b9xz/+gcsuuwzjx48HABQVFeHFF18M0ea53W7k5eUJte/z+VBbW4uuXbtixYoVcLlcAIC9e/di1KhRmDNnDu66666Q4yorK1FZWWlY98MPP4wbbrgB06ZNAwA8/vjjePXVV/H0009j7ty5AIC6ujrDOs6ePYsJEyZg7ty5GDJkiNA5EUTcIyeZlyGI5ghZRogY0mTM1rW1tRg/fjwqKipMyw4ZMgQbNmzAp59+CgD44IMPsGnTphAh7rPPPkN+fj46d+6M6upqfP3117p1yrKM1157Dbt27cKUKVPg8/mwb98+jBo1ChMmTOAKjiKcO3cOO3fuVJ2XLMuoqKjAli1bhOpgjGHq1KkYNWoUJk+ebFh26dKlKC4uxqBBg2z1t1lBg3PsuWY50DIPuPyJWPeEIOIMGp+I2NEkNI8rVqzA+++/j+3btwuVnzt3Lo4fP44ePXrA5XLB6/Vi0aJFqK6uDpYpKyvD8uXL0b17dxw4cAD33Xcfhg8fjj179iA9PZ1bb35+Pt566y0MHz4c1113HbZs2YKKigosW7bM9rkdOXIEXq83xOSdm5uLTz75RKiOzZs3Y+XKlSgtLQ36VD777LPo3bt3SNna2lrU1tbi+PHjyMzMtN3v5gENzjGn/QDgF5+QIE8QWuidIGJI3AuP+/fvx6xZs7Bu3TqkpKQIHbNq1So8//zzeOGFF1BSUoK6ujrMnj0b+fn5qKmpAQCVFrK0tBRlZWUoLCzEqlWrcP311+vWXVBQgGeffRYjRoxA586d8dRTT0GK8Us8bNgw+Hy+mPaBICIGTZIEYQy9I0SUiXuz9c6dO3H48GH0798fbrcbbrcbGzduxCOPPAK32w2v1xtyzJ133om5c+fi2muvRe/evTF58mTcfvvtWLx4sW47WVlZ6NatGz7//HPD/hw6dAgzZsxAVVUVTp8+jdtvvz2s88vJyYHL5cKhQ4dC2hH1xyQiBKXqIQgibiGBkYgdcT87jh49Grt370ZdXV3w38CBA1FdXY26urpg4IqS06dPQ9assetyuQy1cydPnsS+ffuC+RJ5HDlyBKNHj0bPnj3x0ksvYcOGDVi5ciXuuOMO2+fn8XgwYMAAbNiwIbjN5/Nhw4YNKC8vt10v4QA0NhMEEa+QtpGIIXFvtk5PT0evXr1U29LS0pCdnR3c/thjj2HNmjVBAayqqgqLFi1CQUEBSkpKsGvXLjz88MOYPn16sI477rgDVVVVKCwsxLfffosFCxbA5XJh0qRJ3H74fD5UVlaisLAQK1euhNvtRnFxMdatW4dRo0ahffv2XC3kyZMnVdrML7/8EnV1dWjdujUKCgoAAHPmzEFNTQ0GDhyIwYMHY8mSJTh16lQw+pqIFTQ4EwQRr9D4RMSOuBceRThy5Aj27dsX/P3oo49i3rx5uOWWW3D48GHk5+fjxhtvxPz584NlvvnmG0yaNAnff/892rRpg2HDhmHr1q1o06YNtw1ZlvHAAw9g+PDh8Hg8we19+vTB+vXrdY/bsWMHLrroouDvOXPmAABqamqwfPlyAMDEiRPx3XffYf78+Th48CD69u2LN954g5s3kiAIgiBI80jEEokpl10hmg2BaOtjx44hIyMj1t2JLxY2RKGntgLu/ldMu0LEmIWKjAQLj8WuHwSh5fyPwKIGv/gRdwMX/TK2/SESAlHZIO59HgkidtCXPUEQ8QqNT0TsIOGRIPQgsxBBEPEKjU9EDCHhkSB0ocGZIIh4hcYnInaQ8EgQetCXPXHdaiC9HTDlb7HuCUEYQGMVEV0SItqaICIDDcjNnm4X+5dHJIh4gz5uiRhCmkeCIAiCaHKQ8EjEDhIeCUIP+rInCCJeofGJiCEkPBKELjQ4EwRBEIQWEh4JQg/6sicIIm6h8YmIHSQ8EoQuNDgTBBGn0MctEUNIeCQIPWhwJggiXqHxiYghJDwShC40OBMEQRCEFhIeCYIgCKIpQ1pIIsqQ8EgQetCATBAEQRAhkPBIELqQ8EgQBEEQWkh4JAg9SHYkCIIgiBBIeCQIXUh6JAiiKUBjFRFdSHgkCD3I55EgCIIgQiDhkSB0IeGRIAiCILSQ8EgQBEEQTRoW6w4QzQwSHglCDzJbEwRBEEQIJDwShC4kPBIE0RSgsYqILiQ8EoSWUfP8/1/y+9j2gyAIgiDiEHesO0AQccdP7gCG3Aq4k2PdE4IgCIKIO0jzSBA8SHAkCIIgCC4kPBIEQRBEU4aC+4goQ8IjQRAEQRAEIQwJjwRBEARBEIQwJDwSBEEQBEEQwpDwSBAEQRAEQQhDwiNBEARBEAQhDAmPBEEQBEEQhDAkPBIEQRAEQRDCkPBIEARBEARBCEPCI0EQBEE0aShJOBFdSHgkCIIgCIIghCHhkSAIgiAIghCGhEeCIAiCIAhCGBIeCYIgCIIgCGFIeCQIgiCIpgzFyxBRhoRHgiAIgmjKsFh3gGhukPBIEARBEARBCEPCI0EQBEEQBCEMCY8EQRAE0ZQhn0ciypDwSBAEQRAEQQhDwiNBEARBEAQhDAmPBEEQBEEQhDAkPBIEQRAEQRDCkPBIEARBEE0aipghogsJjwRBEARBEIQwJDwSBEEQBEEQwpDwSBAEQRAEQQhDwiNBEARBEAQhDAmPBEEQBEEQhDAkPBIEQRAEQRDCkPCYAOzfvx8jR45EcXExSktLsXr16lh3iSAIgiCIBMUd6w4Q4eN2u7FkyRL07dsXBw8exIABAzBu3DikpaXFumsEQRAEQSQYJDwmAO3atUO7du0AAHl5ecjJycHRo0dJeCQIgmgOSJQknIgucWW2fvDBByFJEmbPnq1bxuv1Yt68eejUqRNSU1PRpUsX3H///WCMBcssXrwYgwYNQnp6Otq2bYsJEyZg7969qnoWLlwISZJU/3r06OH4Ob377ruoqqpCfn4+JEnC2rVrueWWLl2KoqIipKSkoKysDNu2bbPV3s6dO+H1etGxY8cwek0QBEEQBMEnboTH7du3409/+hNKS0sNyz300ENYtmwZHnvsMXz88cd46KGH8Jvf/AaPPvposMzGjRtRW1uLrVu3Yt26dTh//jwuvvhinDp1SlVXSUkJDhw4EPy3adMmw7Y3b96M8+fPh2z/6KOPcOjQIe4xp06dQp8+fbB06VLdeleuXIk5c+ZgwYIFeP/999GnTx+MGTMGhw8fDpbp27cvevXqFfLv22+/DZY5evQopkyZgieeeMLwPAiCIIgEIjkj1j0gmhssDjhx4gTr2rUrW7duHRsxYgSbNWuWbtnx48ez6dOnq7ZdccUVrLq6WveYw4cPMwBs48aNwW0LFixgffr0Ee6j1+tlffr0YVdddRWrr68Pbv/kk09Ybm4ue+ihh0zrAMDWrFkTsn3w4MGstrZW1VZ+fj5bvHixcP/OnDnDhg8fzv7yl78IlT927BgDwI4dOybcBkEQBBFHbHuSsReuZezcj7HuCZEgiMoGcaF5rK2txfjx41FRUWFadsiQIdiwYQM+/fRTAMAHH3yATZs2obKyUveYY8eOAQBat26t2v7ZZ58hPz8fnTt3RnV1Nb7++mvdOmRZxmuvvYZdu3ZhypQp8Pl82LdvH0aNGoUJEybgrrvuEjnVEM6dO4edO3eqzl2WZVRUVGDLli1CdTDGMHXqVIwaNQqTJ082LLt06VIUFxdj0KBBtvpLEARBxAmDfg5MehFISol1T4hmRswDZlasWIH3338f27dvFyo/d+5cHD9+HD169IDL5YLX68WiRYtQXV3NLe/z+TB79mwMHToUvXr1Cm4vKyvD8uXL0b17dxw4cAD33Xcfhg8fjj179iA9PZ1bV35+Pt566y0MHz4c1113HbZs2YKKigosW7bM+ok3cOTIEXi9XuTm5qq25+bm4pNPPhGqY/PmzVi5ciVKS0uDPpXPPvssevfuHVK2trYWtbW1OH78ODIzM233myAIgiCI5klMhcf9+/dj1qxZWLduHVJSxL6cVq1aheeffx4vvPACSkpKUFdXh9mzZyM/Px81NTUh5Wtra7Fnz54Qf0alprK0tBRlZWUoLCzEqlWrcP311+u2X1BQgGeffRYjRoxA586d8dRTT0GKcaTbsGHD4PP5YtoHgiAIgiCaBzE1W+/cuROHDx9G//794Xa74Xa7sXHjRjzyyCNwu93wer0hx9x5552YO3curr32WvTu3RuTJ0/G7bffjsWLF4eUnTlzJl555RW8/fbb6NChg2FfsrKy0K1bN3z++eeG5Q4dOoQZM2agqqoKp0+fxu23327tpDXk5OTA5XKFBNwcOnQIeXl5YdVNEARBEAThNDEVHkePHo3du3ejrq4u+G/gwIGorq5GXV0dXC5XyDGnT5+GLKu77XK5VJo3xhhmzpyJNWvW4K233kKnTp1M+3Ly5Ens27cvmC+Rx5EjRzB69Gj07NkTL730EjZs2ICVK1fijjvusHDWajweDwYMGIANGzYEt/l8PmzYsAHl5eW26yUIgiAIgogEMTVbp6enq/wQASAtLQ3Z2dnB7Y899hjWrFkTFK6qqqqwaNEiFBQUoKSkBLt27cLDDz+M6dOnB+uora3FCy+8gL/97W9IT0/HwYMHAQCZmZlITU0FANxxxx2oqqpCYWEhvv32WyxYsAAulwuTJk3i9tXn86GyshKFhYVYuXIl3G43iouLsW7dOowaNQrt27fnaiFPnjyp0mZ++eWXqKurQ+vWrVFQUAAAmDNnDmpqajBw4EAMHjwYS5YswalTpzBt2jS7l5YgCIIgCCIixDxgxowjR45g3759wd+PPvoo5s2bh1tuuQWHDx9Gfn4+brzxRsyfPz9YJhDAMnLkSFVdzzzzDKZOnQoA+OabbzBp0iR8//33aNOmDYYNG4atW7eiTZs23H7IsowHHngAw4cPh8fjCW7v06cP1q9fr3vcjh07cNFFFwV/z5kzBwBQU1OD5cuXAwAmTpyI7777DvPnz8fBgwfRt29fvPHGGyFBNARBEARBELFGYkyxNAvRbAhEWx87dgwZGZRgliAIgiCaO6KyQVzkeSQIgiAIgiCaBiQ8EgRBEARBEMKQ8EgQBEEQBEEIQ8IjQRAEQRAEIQwJjwRBEARBEIQwJDwSBEEQBEEQwpDwSBAEQRAEQQhDwiNBEARBEAQhDAmPBEEQBEEQhDAkPBIEQRAEQRDCkPBIEARBEARBCEPCI0EQBEEQBCEMCY8EQRAEQRCEMO5Yd4CIDYwxAMDx48dj3BOCIAiCIOKBgEwQkBH0IOGxmXLixAkAQMeOHWPcE4IgCIIg4okTJ04gMzNTd7/EzMRLIiHx+Xz49ttvkZ6eDkmSHK//+PHj6NixI/bv34+MjAzH648n6FwTEzrXxITONTGhc3UGxhhOnDiB/Px8yLK+ZyNpHpspsiyjQ4cOEW8nIyMj4V/kAHSuiQmda2JC55qY0LmGj5HGMQAFzBAEQRAEQRDCkPBIEARBEARBCEPCIxERKveTgwAAD2BJREFUkpOTsWDBAiQnJ8e6KxGHzjUxoXNNTOhcExM61+hCATMEQRAEQRCEMKR5JAiCIAiCIIQh4ZEgCIIgCIIQhoRHgiAIgiAIQhgSHgnHWbp0KYqKipCSkoKysjJs27Yt1l2yzLvvvouqqirk5+dDkiSsXbtWtZ8xhvnz56Ndu3ZITU1FRUUFPvvsM1WZo0ePorq6GhkZGcjKysL111+PkydPRvEsxFi8eDEGDRqE9PR0tG3bFhMmTMDevXtVZc6cOYPa2lpkZ2ejZcuWuPLKK3Ho0CFVma+//hrjx49HixYt0LZtW9x5552or6+P5qmYsmzZMpSWlgbzo5WXl+P1118P7k+U89Ty4IMPQpIkzJ49O7gtkc514cKFkCRJ9a9Hjx7B/Yl0rgDw73//Gz/72c+QnZ2N1NRU9O7dGzt27AjuT5TxqaioKOS+SpKE2tpaAIl1X71eL+bNm4dOnTohNTUVXbp0wf33369aJjCu7isjCAdZsWIF83g87Omnn2b//Oc/2Q033MCysrLYoUOHYt01S7z22mvs3nvvZS+99BIDwNasWaPa/+CDD7LMzEy2du1a9sEHH7BLL72UderUif3444/BMmPHjmV9+vRhW7duZf/3f//HLrjgAjZp0qQon4k5Y8aMYc888wzbs2cPq6urY+PGjWMFBQXs5MmTwTI33XQT69ixI9uwYQPbsWMHu/DCC9mQIUOC++vr61mvXr1YRUUF27VrF3vttddYTk4Ou+eee2JxSrq8/PLL7NVXX2Wffvop27t3L/vlL3/JkpKS2J49exhjiXOeSrZt28aKiopYaWkpmzVrVnB7Ip3rggULWElJCTtw4EDw33fffRfcn0jnevToUVZYWMimTp3K3nvvPfbFF1+wN998k33++efBMokyPh0+fFh1T9etW8cAsLfffpsxllj3ddGiRSw7O5u98sor7Msvv2SrV69mLVu2ZH/4wx+CZeLpvpLwSDjK4MGDWW1tbfC31+tl+fn5bPHixTHsVXhohUefz8fy8vLYb3/72+C2H374gSUnJ7MXX3yRMcbYRx99xACw7du3B8u8/vrrTJIk9u9//ztqfbfD4cOHGQC2ceNGxpj/3JKSktjq1auDZT7++GMGgG3ZsoUx5he2ZVlmBw8eDJZZtmwZy8jIYGfPno3uCVikVatW7H/+538S8jxPnDjBunbtytatW8dGjBgRFB4T7VwXLFjA+vTpw92XaOd69913s2HDhunuT+TxadasWaxLly7M5/Ml3H0dP348mz59umrbFVdcwaqrqxlj8XdfyWxNOMa5c+ewc+dOVFRUBLfJsoyKigps2bIlhj1zli+//BIHDx5UnWdmZibKysqC57llyxZkZWVh4MCBwTIVFRWQZRnvvfde1PtshWPHjgEAWrduDQDYuXMnzp8/rzrfHj16oKCgQHW+vXv3Rm5ubrDMmDFjcPz4cfzzn/+MYu/F8Xq9WLFiBU6dOoXy8vKEPM/a2lqMHz9edU5AYt7Tzz77DPn5+ejcuTOqq6vx9ddfA0i8c3355ZcxcOBAXH311Wjbti369euHJ598Mrg/Ucenc+fO4bnnnsP06dMhSVLC3dchQ4Zgw4YN+PTTTwEAH3zwATZt2oTKykoA8XdfaW1rwjGOHDkCr9erelEBIDc3F5988kmMeuU8Bw8eBADueQb2HTx4EG3btlXtd7vdaN26dbBMPOLz+TB79mwMHToUvXr1AuA/F4/Hg6ysLFVZ7fnyrkdgXzyxe/dulJeX48yZM2jZsiXWrFmD4uJi1NXVJdR5rlixAu+//z62b98esi/R7mlZWRmWL1+O7t2748CBA7jvvvswfPhw7NmzJ+HO9YsvvsCyZcswZ84c/PKXv8T27dtx2223wePxoKamJmHHp7Vr1+KHH37A1KlTASTeMzx37lwcP34cPXr0gMvlgtfrxaJFi1BdXQ0g/uYdEh4JgghSW1uLPXv2YNOmTbHuSsTo3r076urqcOzYMfz1r39FTU0NNm7cGOtuOcr+/fsxa9YsrFu3DikpKbHuTsQJaGcAoLS0FGVlZSgsLMSqVauQmpoaw545j8/nw8CBA/HAAw8AAPr164c9e/bg8ccfR01NTYx7FzmeeuopVFZWIj8/P9ZdiQirVq3C888/jxdeeAElJSWoq6vD7NmzkZ+fH5f3lczWhGPk5OTA5XKFRLsdOnQIeXl5MeqV8wTOxeg88/LycPjwYdX++vp6HD16NG6vxcyZM/HKK6/g7bffRocOHYLb8/LycO7cOfzwww+q8trz5V2PwL54wuPx4IILLsCAAQOwePFi9OnTB3/4wx8S6jx37tyJw4cPo3///nC73XC73di4cSMeeeQRuN1u5ObmJsy58sjKykK3bt3w+eefJ9R9BYB27dqhuLhYta1nz55BM30ijk9fffUV1q9fj5///OfBbYl2X++8807MnTsX1157LXr37o3Jkyfj9ttvx+LFiwHE330l4ZFwDI/HgwEDBmDDhg3BbT6fDxs2bEB5eXkMe+YsnTp1Ql5enuo8jx8/jvfeey94nuXl5fjhhx+wc+fOYJm33noLPp8PZWVlUe+zEYwxzJw5E2vWrMFbb72FTp06qfYPGDAASUlJqvPdu3cvvv76a9X57t69WzVwrVu3DhkZGSETXbzh8/lw9uzZhDrP0aNHY/fu3airqwv+GzhwIKqrq4N/J8q58jh58iT27duHdu3aJdR9BYChQ4eGpNL69NNPUVhYCCDxxicAeOaZZ9C2bVuMHz8+uC3R7uvp06chy2qRzOVywefzAYjD++po+A3R7FmxYgVLTk5my5cvZx999BGbMWMGy8rKUkW7NQVOnDjBdu3axXbt2sUAsIcffpjt2rWLffXVV4wxf8qErKws9re//Y19+OGH7LLLLuOmTOjXrx9777332KZNm1jXrl3jLhUGY4zdfPPNLDMzk73zzjuqtBinT58OlrnppptYQUEBe+utt9iOHTtYeXk5Ky8vD+4PpMS4+OKLWV1dHXvjjTdYmzZt4i4lxty5c9nGjRvZl19+yT788EM2d+5cJkkS+/vf/84YS5zz5KGMtmYssc71F7/4BXvnnXfYl19+yTZv3swqKipYTk4OO3z4MGMssc5127ZtzO12s0WLFrHPPvuMPf/886xFixbsueeeC5ZJpPHJ6/WygoICdvfdd4fsS6T7WlNTw9q3bx9M1fPSSy+xnJwcdtdddwXLxNN9JeGRcJxHH32UFRQUMI/HwwYPHsy2bt0a6y5Z5u2332YAQv7V1NQwxvxpE+bNm8dyc3NZcnIyGz16NNu7d6+qju+//55NmjSJtWzZkmVkZLBp06axEydOxOBsjOGdJwD2zDPPBMv8+OOP7JZbbmGtWrViLVq0YJdffjk7cOCAqp5//etfrLKykqWmprKcnBz2i1/8gp0/fz7KZ2PM9OnTWWFhIfN4PKxNmzZs9OjRQcGRscQ5Tx5a4TGRznXixImsXbt2zOPxsPbt27OJEyeq8h4m0rkyxtj//u//sl69erHk5GTWo0cP9sQTT6j2J9L49OabbzIAIf1nLLHu6/Hjx9msWbNYQUEBS0lJYZ07d2b33nuvKqVQPN1XiTFF+nKCIAiCIAiCMIB8HgmCIAiCIAhhSHgkCIIgCIIghCHhkSAIgiAIghCGhEeCIAiCIAhCGBIeCYIgCIIgCGFIeCQIgiAIgiCEIeGRIAiCIAiCEIaER4IgCIIgCEIYEh4JgiAIISRJwtq1a2PdDYIgYgwJjwRBEE2AqVOnQpKkkH9jx46NddcIgmhmuGPdAYIgCEKMsWPH4plnnlFtS05OjlFvCIJorpDmkSAIoomQnJyMvLw81b9WrVoB8JuUly1bhsrKSqSmpqJz587461//qjp+9+7dGDVqFFJTU5GdnY0ZM2bg5MmTqjJPP/00SkpKkJycjHbt2mHmzJmq/UeOHMHll1+OFi1aoGvXrnj55ZeD+/7zn/+guroabdq0QWpqKrp27Roi7BIE0fQh4ZEgCCJBmDdvHq688kp88MEHqK6uxrXXXouPP/4YAHDq1CmMGTMGrVq1wvbt27F69WqsX79eJRwuW7YMtbW1mDFjBnbv3o2XX34ZF1xwgaqN++67D9dccw0+/PBDjBs3DtXV1Th69Giw/Y8++givv/46Pv74Yyxbtgw5OTnRuwAEQUQHRhAEQcQ9NTU1zOVysbS0NNW/RYsWMcYYA8Buuukm1TFlZWXs5ptvZowx9sQTT7BWrVqxkydPBve/+uqrTJZldvDgQcYYY/n5+ezee+/V7QMA9qtf/Sr4++TJkwwAe/311xljjFVVVbFp06Y5c8IEQcQt5PNIEATRRLjooouwbNky1bbWrVsH/y4vL1ftKy8vR11dHQDg448/Rp8+fZCWlhbcP3ToUPh8PuzduxeSJOHbb7/F6NGjDftQWloa/DstLQ0ZGRk4fPgwAODmm2/GlVdeiffffx8XX3wxJkyYgCFDhtg6V4Ig4hcSHgmCIJoIaWlpIWZkp0hNTRUql5SUpPotSRJ8Ph8AoLKyEl999RVee+01rFu3DqNHj0ZtbS1+97vfOd5fgiBiB/k8EgRBJAhbt24N+d2zZ08AQM+ePfHBBx/g1KlTwf2bN2+GLMvo3r070tPTUVRUhA0bNoTVhzZt2qCmpgbPPfcclixZgieeeCKs+giCiD9I80gQBNFEOHv2LA4ePKja5na7g0Epq1evxsCBAzFs2DA8//zz2LZtG5566ikAQHV1NRYsWICamhosXLgQ3333HW699VZMnjwZubm5AICFCxfipptuQtu2bVFZWYkTJ05g8+bNuPXWW4X6N3/+fAwYMAAlJSU4e/YsXnnllaDwShBE4kDCI0EQRBPhjTfeQLt27VTbunfvjk8++QSAPxJ6xYoVuOWWW9CuXTu8+OKLKC4uBgC0aNECb775JmbNmoVBgwahRYsWuPLKK/Hwww8H66qpqcGZM2fw+9//HnfccQdycnJw1VVXCffP4/Hgnnvuwb/+9S+kpqZi+PDhWLFihQNnThBEPCExxlisO0EQBEGEhyRJWLNmDSZMmBDrrhAEkeCQzyNBEARBEAQhDAmPBEEQBEEQhDDk80gQBJEAkAcSQRDRgjSPBEEQBEEQhDAkPBIEQRAEQRDCkPBIEARBEARBCEPCI0EQBEEQBCEMCY8EQRAEQRCEMCQ8EgRBEARBEMKQ8EgQBEEQBEEIQ8IjQRAEQRAEIQwJjwRBEARBEIQw/x8gy8IfNPwiVAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "\n", - "# Extract the losses from the history object\n", - "train_loss = history.history['loss']\n", - "val_loss = history.history['val_loss']\n", - "\n", - "\n", - "train_loss_x_midpoints = history.history.get('x_midpoints_reshape_loss', train_loss)\n", - "val_loss_x_midpoints = history.history.get('val_x_midpoints_reshape_loss', val_loss)\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.subplot(1, 2,1)\n", - "plt.plot(train_loss_x_midpoints, label='Train Loss x_midpoints_reshape')\n", - "plt.plot(val_loss_x_midpoints, label='Validation Loss x_midpoints_reshape')\n", - "plt.xlabel('Epochs')\n", - "plt.yscale('log')\n", - "\n", - "plt.ylabel('Loss')\n", - "plt.title('Training and Validation Loss ')\n", - "plt.legend()\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/da886/anaconda3/envs/objectdetection/lib/python3.11/site-packages/keras/src/saving/saving_lib.py:576: UserWarning: Skipping variable loading for optimizer 'rmsprop', because it has 38 variables whereas the saved optimizer has 74 variables. \n", - " saveable.load_own_variables(weights_store.get(inner_path))\n" - ] - } - ], - "source": [ - "# loaded_model = tf.keras.models.load_model(\n", - "# \"/home/da886/Electron Counting Extended Arch/Weights For Classes/3onlymixed.keras\",safe_mode=False,\n", - "# custom_objects={'DynamicExponentCallback': DynamicExponentCallback, 'custom_loss': custom_loss}\n", - "# )\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n" - ] - } - ], - "source": [ - "model_builder.model.save('/home/da886/Final Electron counting project/Experimental weights/JoshMSE5fixed.h5')" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 2ms/step \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "W0000 00:00:1727101913.170576 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.170917 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.171744 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.172595 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.172899 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.173265 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.173278 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.173479 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.173863 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.173970 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.174125 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.174370 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.174964 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.175174 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.175581 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.175618 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.175760 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.176202 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.176442 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.176458 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.176838 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.177102 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.177147 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.177399 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.178473 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.178563 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.178589 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.179328 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.179466 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.179470 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.180127 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.180450 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.180618 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.181014 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.181465 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.181494 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.182252 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.182285 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.182316 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.182734 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.193530 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.193895 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.194177 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.194490 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.194673 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.194975 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.195139 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.195377 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.195490 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.195875 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.196001 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.196293 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.196481 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.196999 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.197072 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.197462 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.197825 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.202718 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.202763 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.203415 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.203423 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.203839 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.203941 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.204068 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.204809 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.204812 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.204844 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.205656 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.205777 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.206210 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.206414 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.207123 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.207873 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.208480 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.209385 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.210092 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.210859 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.211604 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.212462 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.213342 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.214185 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.215261 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.215469 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.216059 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.216587 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.216768 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.216785 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.217108 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.217497 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.217638 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.218457 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.218485 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.218485 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.218988 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.219424 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.219469 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.219618 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.220508 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.220612 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.220637 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.221305 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.221463 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.222227 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.222321 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.223196 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.223341 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.223367 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.224418 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.224465 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.224543 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.225269 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.225441 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.226042 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.226340 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.226925 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.227211 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.227690 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.228299 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.228778 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.229504 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.229868 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.230842 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.231153 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.231313 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.231614 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.231660 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.231952 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.232182 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.232245 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.232690 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.232913 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.233075 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.233305 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.233681 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.234046 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.234415 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.234791 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.235330 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.235362 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.235507 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.235992 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.236360 742078 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.236457 742171 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.236599 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.237101 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.237802 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n", - "W0000 00:00:1727101913.238223 742093 gpu_timer.cc:114] Skipping the delay kernel, measurement accuracy will be reduced\n" - ] - } - ], - "source": [ - "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", - "train_dataset = train_dataset.batch(800)\n", - "inputs,targets = next(iter(train_dataset))\n", - "outputs = model_builder.model.predict(inputs)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def visualize_midpoints(image, midpoints):\n", - " \"\"\"\n", - " Visualizes midpoints on an image without using a probability vector.\n", - "\n", - " Parameters:\n", - " - image: A 3D tensor representing the image.\n", - " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", - "\n", - " Returns:\n", - " None (displays the image with midpoints).\n", - " \"\"\"\n", - " # Convert to NumPy arrays for easier handling\n", - " image_np = image\n", - " midpoints_np = midpoints\n", - "\n", - " # Denormalize image if necessary (adjust based on your normalization method)\n", - " denormalized_image = image_np # Modify if normalization was applied during training\n", - "\n", - " # Visualize the image\n", - " plt.figure(figsize=(4, 4))\n", - " plt.imshow(denormalized_image, cmap='gray')\n", - " plt.title(\"Predicted Midpoint Visualization\")\n", - "\n", - " # Plot midpoints directly\n", - " for i, (x, y) in enumerate(midpoints_np):\n", - " plt.scatter(x, y, color='red', s=5)\n", - "\n", - " plt.show()\n", - "\n", - "def visualize_midpoints2(image, midpoints):\n", - " \"\"\"\n", - " Visualizes ground truth midpoints on an image without using a probability vector.\n", - "\n", - " Parameters:\n", - " - image: A 3D tensor representing the image.\n", - " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", - "\n", - " Returns:\n", - " None (displays the image with midpoints).\n", - " \"\"\"\n", - " \n", - " image_np = image\n", - " midpoints_np = midpoints\n", - " denormalized_image = image_np \n", - "\n", - " # Visualize the image\n", - " plt.figure(figsize=(4, 4))\n", - " plt.imshow(denormalized_image, cmap='gray')\n", - " plt.title(\"Ground Truth Midpoint Visualization\")\n", - "\n", - " # Plot midpoints directly\n", - " for i, (x, y) in enumerate(midpoints_np):\n", - " plt.scatter(x, y, color='red', s=5)\n", - "\n", - " plt.show()\n", - "\n", - "# Example usage with random data\n", - "t = np.random.randint(0, 800)\n", - "# t=100\n", - "\n", - "visualize_midpoints(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(outputs[t,0,:,:])*64)\n", - "visualize_midpoints2(tf.convert_to_tensor(inputs[t]), tf.convert_to_tensor(targets[t,0,:,:])*64)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing batch 1, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 2, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 3, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 4, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 5, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 6, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 7, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 8, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 9, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 10, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 11, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 12, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 1ms/step \n", - "Processing batch 13, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 14, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 15, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 16, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 17, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 18, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 19, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 20, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 21, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 22, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 23, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 24, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 25, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 26, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 27, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 28, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n", - "Processing batch 29, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n", - "Processing batch 30, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step \n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import tensorflow as tf\n", - "\n", - "# Define the function for visualizing midpoints\n", - "def visualize_midpoints(image, midpoints, title=\"Predicted Midpoint Visualization\"):\n", - " \"\"\"\n", - " Visualizes midpoints on an image without using a probability vector.\n", - "\n", - " Parameters:\n", - " - image: A 3D tensor representing the image.\n", - " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", - " - title: The title of the plot.\n", - "\n", - " Returns:\n", - " None (displays the image with midpoints).\n", - " \"\"\"\n", - " # Convert to NumPy arrays for easier handling\n", - " image_np = image\n", - " midpoints_np = midpoints\n", - "\n", - " # Denormalize image if necessary (adjust based on your normalization method)\n", - " denormalized_image = image_np # Modify if normalization was applied during training\n", - "\n", - " # Visualize the image\n", - " plt.figure(figsize=(4, 4))\n", - " plt.imshow(denormalized_image, cmap='gray')\n", - " plt.title(title)\n", - "\n", - " # Plot midpoints directly, only if they are not (0, 0)\n", - " for i, (x, y) in enumerate(midpoints_np):\n", - " if x >= 3 and y >= 3: # Only plot if the point is not (0, 0)\n", - " plt.scatter(x, y, color='red', s=5)\n", - "\n", - " plt.show()\n", - "\n", - "# Create the validation dataset\n", - "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", - "# val_dataset = val_dataset.batch(800)\n", - "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", - "train_dataset = train_dataset.batch(800)\n", - "\n", - "# Initialize lists to collect the data\n", - "all_images = []\n", - "all_true_midpoints = []\n", - "all_pred_midpoints = []\n", - "\n", - "# Loop through each batch in the validation dataset, predict, and collect results\n", - "# for i, (data_batch, midpoints_batch) in enumerate(val_dataset):\n", - "\n", - "for i, (data_batch, midpoints_batch) in enumerate(train_dataset):\n", - " print(f\"Processing batch {i + 1}, batch shape: {data_batch.shape}\")\n", - " \n", - " # Get the model predictions\n", - " predictions = model_builder.model.predict(data_batch)\n", - "\n", - " # Extend the lists to store data from each batch\n", - " all_images.extend(data_batch.numpy()) # Store all images\n", - " all_true_midpoints.extend(midpoints_batch.numpy()) # Store all true midpoints\n", - " all_pred_midpoints.extend(predictions) # Store all predicted midpoints\n", - "\n", - "# Convert lists to arrays for easier indexing\n", - "all_images = np.array(all_images)\n", - "all_true_midpoints = np.array(all_true_midpoints)\n", - "all_pred_midpoints = np.array(all_pred_midpoints)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(800, 1, 5, 2)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "predictions.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Select an index to visualize from the entire dataset\n", - "index_to_visualize = np.random.randint(0, len(all_images))\n", - "\n", - "# index_to_visualize = 11548\n", - "# Visualize the selected image with predicted and true midpoints\n", - "visualize_midpoints(all_images[index_to_visualize], all_pred_midpoints[index_to_visualize, 0, :, :] * 64, title=\"Predicted Midpoints\")\n", - "visualize_midpoints(all_images[index_to_visualize], all_true_midpoints[index_to_visualize, 0, :, :] * 64, title=\"Ground Truth Midpoints\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "code to visualize Josh's edit" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [], - "source": [ - "# model_builder.model.save('/home/da886/Electron Counting Extended Arch/Overfitted weights/increased_model_Padded_weights.keras')" - ] - }, - { - "cell_type": "code", - "execution_count": 268, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 193ms/step - loss: 0.0136\n" - ] - } - ], - "source": [ - "val_loss = model_builder.model.evaluate(val_dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Initialize variables to track the min and max MSE\n", - "min_mse = float('inf')\n", - "max_mse = float('-inf')\n", - "min_mse_index = -1\n", - "max_mse_index = -1\n", - "\n", - "# Loop through each prediction to calculate the MSE\n", - "for i in range(len(all_pred_midpoints)):\n", - " mse = np.mean((all_pred_midpoints[i] - all_true_midpoints[i]) ** 2)\n", - " \n", - " if mse < min_mse:\n", - " min_mse = mse\n", - " min_mse_index = i\n", - " \n", - " if mse > max_mse:\n", - " max_mse = mse\n", - " max_mse_index = i\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Function to plot an image with its centers\n", - "def plot_image_with_centers(image, true_center, predicted_center, title):\n", - " plt.figure(figsize=(5, 5))\n", - " plt.imshow(image.squeeze(), cmap='gray') # Display the image\n", - "\n", - " # Plot the actual center (Groundtruth)\n", - " plt.scatter(true_center[:, 0], true_center[:, 1], color='green', label='Groundtruth', s=10)\n", - "\n", - " # Plot the predicted center\n", - " plt.scatter(predicted_center[:, 0], predicted_center[:, 1], color='red', label='Predictions', s=10)\n", - "\n", - " plt.title(title)\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "# Plotting the image with the least MSE\n", - "plot_image_with_centers(all_images[min_mse_index],\n", - " all_true_midpoints[min_mse_index][0] * 64, # Adjust for scaling if needed\n", - " all_pred_midpoints[min_mse_index][0] * 64, # Adjust for scaling if needed\n", - " f'Image with Least MSE. MSE: {min_mse:.4f}')\n", - "\n", - "# Plotting the image with the largest MSE\n", - "plot_image_with_centers(all_images[max_mse_index],\n", - " all_true_midpoints[max_mse_index][0] * 64, # Adjust for scaling if needed\n", - " all_pred_midpoints[max_mse_index][0] * 64, # Adjust for scaling if needed\n", - " f'Image with Largest MSE. MSE: {max_mse:.4f}')\n", - "\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "objectdetection", - "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.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Object_Detection/keras2hls.ipynb b/Object_Detection/keras2hls.ipynb new file mode 100644 index 0000000..ecb1cfa --- /dev/null +++ b/Object_Detection/keras2hls.ipynb @@ -0,0 +1,37 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers, Model\n", + "from sklearn.model_selection import train_test_split\n", + "import h5py\n", + "import os \n", + "import hls4ml\n", + "from hls4ml.optimization import optimize_keras_model_for_hls4ml\n", + "from hls4ml.optimization.attributes import get_attributes_from_keras_model\n", + "from hls4ml.optimization.keras import optimize_model\n", + "from hls4ml.optimization.keras.utils import get_model_sparsity\n", + "from hls4ml.optimization.objectives import ParameterEstimator\n", + "from hls4ml.optimization.objectives.vivado_objectives import VivadoDSPEstimator\n", + "from hls4ml.optimization.scheduler import PolynomialScheduler" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ResNet34.ipynb b/ResNet34.ipynb deleted file mode 100644 index e10a2f7..0000000 --- a/ResNet34.ipynb +++ /dev/null @@ -1,945 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-11 18:27:53.421815: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2024-09-11 18:27:53.436002: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2024-09-11 18:27:53.449545: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2024-09-11 18:27:53.453456: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "2024-09-11 18:27:53.464789: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2024-09-11 18:27:54.061630: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "device /gpu:0\n" - ] - } - ], - "source": [ - "import os\n", - "import tensorflow as tf\n", - "\n", - "# Set CUDA device order and visible devices\n", - "os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0,1,2,3,4,5,6,7,8,9\"\n", - "\n", - "# Set the device\n", - "device = '/cpu:0' \n", - "if tf.config.experimental.list_physical_devices('GPU'):\n", - " try:\n", - " # Restrict TensorFlow to only use the second GPU\n", - " gpus = tf.config.experimental.list_physical_devices('GPU')\n", - " if gpus:\n", - " tf.config.experimental.set_visible_devices(gpus[0], 'GPU')\n", - " device = '/gpu:0'\n", - " except RuntimeError as e:\n", - " print(e)\n", - "\n", - "print(\"device\", device)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import tqdm\n", - "import h5py\n", - "from sklearn.model_selection import train_test_split\n", - "from tensorflow.keras import layers, callbacks\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "class DataLoader:\n", - " def __init__(self, h5_filename):\n", - " self.h5_filename = h5_filename\n", - " self.images, self.centers = self.load_data()\n", - "\n", - " def load_data(self):\n", - " with h5py.File(self.h5_filename, 'r') as f:\n", - " images = np.array(f['images'])\n", - " centers = np.array(f['centers_training'])\n", - " return images, centers\n", - "\n", - " def plot_image_with_centers(self, image_index=None):\n", - " if image_index is None:\n", - " image_index = np.random.randint(0, len(self.images))\n", - "\n", - " image = self.images[image_index]\n", - " centers = self.centers[image_index]\n", - "\n", - " plt.imshow(image, cmap='gray')\n", - " valid_centers = centers[centers[:, 0] == 1]\n", - " for center in valid_centers:\n", - " plt.scatter(center[1], center[2], c='red', marker='x') # center[1] is x and center[2] is y\n", - " plt.title('Image with Valid Centers Marked')\n", - " plt.colorbar()\n", - " plt.show()\n", - "\n", - " @staticmethod\n", - " def sort_centers(centers):\n", - " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", - "\n", - " def normalize_data(self):\n", - " normalized_images = self.images / np.max(self.images)\n", - " sorted_centers = np.array([self.sort_centers(image_centers[:, 1:]) for image_centers in self.centers])\n", - " normalized_centers = sorted_centers / 64\n", - " \n", - " normalized_midpoints = tf.expand_dims(normalized_centers, axis=1)\n", - " return normalized_images, normalized_midpoints.numpy()\n", - "\n", - " def split_data(self, train_size=0.8, random_state=42):\n", - " normalized_images, normalized_midpoints_np = self.normalize_data()\n", - " return train_test_split(normalized_images, normalized_midpoints_np, train_size=train_size, random_state=random_state)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def plot_transposed_images_with_midpoints(dataset, image_indices=[0, 1, 2, 3]):\n", - " \"\"\"\n", - " Extracts multiple images and their midpoints from the given dataset, transposes the images, \n", - " corrects the midpoints, and plots the transposed images with the corrected midpoints.\n", - "\n", - " Args:\n", - " - dataset (tf.data.Dataset): The dataset from which to extract the images and midpoints.\n", - " - image_indices (list): The indices of the images in the batch to visualize. Default is [0, 1, 2, 3].\n", - " \"\"\"\n", - "\n", - " # Extract a sample image batch and its corresponding midpoints from the dataset\n", - " sample_image_batch, sample_midpoints_batch = next(iter(dataset))\n", - "\n", - " # Create a figure with 2x2 subplots\n", - " fig, axes = plt.subplots(2, 2, figsize=(6, 6))\n", - "\n", - " for i, ax in enumerate(axes.flat):\n", - " if i < len(image_indices):\n", - " # Select the specified image and corresponding midpoints from the batch\n", - " sample_image = np.array(sample_image_batch[image_indices[i]])\n", - " sample_midpoints = np.array(sample_midpoints_batch[image_indices[i]])\n", - "\n", - " # Transpose the image\n", - " transposed_image = sample_image.T\n", - "\n", - " # Correct the midpoints by swapping the x and y coordinates\n", - " transposed_midpoints_corrected = sample_midpoints[:, :, [1, 0]]\n", - "\n", - " # Plot the transposed image with corrected midpoints\n", - " ax.imshow(transposed_image, cmap='gray')\n", - " ax.scatter(\n", - " transposed_midpoints_corrected[:, :, 0] * 64, \n", - " transposed_midpoints_corrected[:, :, 1] * 64, \n", - " \n", - " c='red', marker='o',s=5\n", - " )\n", - " ax.set_title(f'Image {image_indices[i]} for this batch')\n", - " else:\n", - " ax.axis('off') # If fewer than 4 images are requested, hide the unused subplots\n", - "\n", - " plt.tight_layout()\n", - " plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "from tensorflow.keras import layers, models\n", - "\n", - "class ModelBuilder:\n", - " def __init__(self, input_shape=(64, 64, 1), num_classes=5, num_coordinates=2, learning_rate=3e-5, weights_path=None):\n", - " self.input_shape = input_shape\n", - " self.num_classes = num_classes\n", - " self.num_coordinates = num_coordinates\n", - " self.learning_rate = learning_rate\n", - " self.model = self.build_model()\n", - "\n", - " # Load weights if a path is provided\n", - " if weights_path is not None:\n", - " self.model.load_weights(weights_path)\n", - "\n", - " self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)\n", - "\n", - " def resnet34(self, input_shape=(64, 64, 1), num_classes=5):\n", - " \"\"\"ResNet34 Architecture.\"\"\"\n", - " bn_axis = 3 if tf.keras.backend.image_data_format() == 'channels_last' else 1\n", - "\n", - " inputs = layers.Input(shape=input_shape)\n", - "\n", - " # Initial conv + max pool\n", - " x = layers.Conv2D(64, 7, strides=2, padding='same', name='conv1_conv')(inputs)\n", - " x = layers.BatchNormalization(axis=bn_axis, name='conv1_bn')(x)\n", - " x = layers.ReLU(name='conv1_relu')(x)\n", - " x = layers.MaxPooling2D(3, strides=2, padding='same', name='pool1_pool')(x)\n", - "\n", - " # Conv2_x\n", - " x = conv_block(x, 64, stride=1, conv_shortcut=False, name='conv2_block1')\n", - " x = identity_block(x, 64, name='conv2_block2')\n", - " x = identity_block(x, 64, name='conv2_block3')\n", - "\n", - " # Conv3_x\n", - " x = conv_block(x, 128, stride=2, name='conv3_block1')\n", - " x = identity_block(x, 128, name='conv3_block2')\n", - " x = identity_block(x, 128, name='conv3_block3')\n", - " x = identity_block(x, 128, name='conv3_block4')\n", - "\n", - " # Conv4_x\n", - " x = conv_block(x, 256, stride=2, name='conv4_block1')\n", - " x = identity_block(x, 256, name='conv4_block2')\n", - " x = identity_block(x, 256, name='conv4_block3')\n", - " x = identity_block(x, 256, name='conv4_block4')\n", - " x = identity_block(x, 256, name='conv4_block5')\n", - " x = identity_block(x, 256, name='conv4_block6')\n", - "\n", - " # Conv5_x\n", - " x = conv_block(x, 512, stride=2, name='conv5_block1')\n", - " x = identity_block(x, 512, name='conv5_block2')\n", - " x = identity_block(x, 512, name='conv5_block3')\n", - "\n", - " return x, inputs\n", - "\n", - " def build_model(self):\n", - " x, inputs = self.resnet34(input_shape=self.input_shape, num_classes=self.num_classes)\n", - " \n", - " # Global pooling and additional layers for midpoint prediction\n", - " x = layers.GlobalAveragePooling2D(name='avg_pool')(x)\n", - "\n", - " x_midpoints = layers.Dense(self.num_classes * self.num_coordinates, activation='sigmoid', name='x_midpoints')(x)\n", - " x_midpoints_reshape = layers.Reshape((-1, self.num_classes, self.num_coordinates), name='x_midpoints_reshape')(x_midpoints)\n", - "\n", - " return models.Model(inputs, x_midpoints_reshape)\n", - "\n", - " def compile_model(self, loss_function):\n", - " self.model.compile(optimizer=self.optimizer, loss=loss_function)\n", - "\n", - " def train_model(self, train_dataset, val_dataset, epochs, callbacks_list):\n", - " history = self.model.fit(train_dataset, epochs=epochs, validation_data=val_dataset, callbacks=callbacks_list)\n", - " return history\n", - "\n", - "\n", - "# Define helper functions for conv_block and identity_block (from Model B)\n", - "def conv_block(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):\n", - " \"\"\"A block with convolution layers that can optionally downsample the input.\"\"\"\n", - " bn_axis = 3 if tf.keras.backend.image_data_format() == 'channels_last' else 1\n", - "\n", - " if conv_shortcut:\n", - " shortcut = layers.Conv2D(filters, 1, strides=stride, name=name + '_0_conv')(x)\n", - " shortcut = layers.BatchNormalization(axis=bn_axis, name=name + '_0_bn')(shortcut)\n", - " else:\n", - " shortcut = x\n", - "\n", - " x = layers.Conv2D(filters, kernel_size, strides=stride, padding='same', name=name + '_1_conv')(x)\n", - " x = layers.BatchNormalization(axis=bn_axis, name=name + '_1_bn')(x)\n", - " x = layers.ReLU(name=name + '_1_relu')(x)\n", - "\n", - " x = layers.Conv2D(filters, kernel_size, padding='same', name=name + '_2_conv')(x)\n", - " x = layers.BatchNormalization(axis=bn_axis, name=name + '_2_bn')(x)\n", - "\n", - " x = layers.Add(name=name + '_add')([shortcut, x])\n", - " x = layers.ReLU(name=name + '_out')(x)\n", - " return x\n", - "\n", - "def identity_block(x, filters, kernel_size=3, name=None):\n", - " \"\"\"A block that preserves input size.\"\"\"\n", - " bn_axis = 3 if tf.keras.backend.image_data_format() == 'channels_last' else 1\n", - "\n", - " shortcut = x\n", - "\n", - " x = layers.Conv2D(filters, kernel_size, padding='same', name=name + '_1_conv')(x)\n", - " x = layers.BatchNormalization(axis=bn_axis, name=name + '_1_bn')(x)\n", - " x = layers.ReLU(name=name + '_1_relu')(x)\n", - "\n", - " x = layers.Conv2D(filters, kernel_size, padding='same', name=name + '_2_conv')(x)\n", - " x = layers.BatchNormalization(axis=bn_axis, name=name + '_2_bn')(x)\n", - "\n", - " x = layers.Add(name=name + '_add')([shortcut, x])\n", - " x = layers.ReLU(name=name + '_out')(x)\n", - " return x\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "\n", - "class SimpleCyclicLR(tf.keras.callbacks.Callback):\n", - " \"\"\"A simple Cyclic Learning Rate (CLR) callback.\"\"\"\n", - "\n", - " def __init__(self, base_lr=1e-4, max_lr=1e-2, step_size=2000, mode='triangular'):\n", - " super(SimpleCyclicLR, self).__init__()\n", - " self.base_lr = base_lr\n", - " self.max_lr = max_lr\n", - " self.step_size = step_size\n", - " self.mode = mode\n", - " self.iterations = 0\n", - " self.history = {}\n", - "\n", - " def clr(self):\n", - " \"\"\"Calculate learning rate according to the current iteration.\"\"\"\n", - " cycle = tf.floor(1 + self.iterations / (2 * self.step_size))\n", - " x = tf.abs(self.iterations / self.step_size - 2 * cycle + 1)\n", - " learning_rate = self.base_lr + (self.max_lr - self.base_lr) * tf.maximum(0., (1 - x))\n", - " return learning_rate\n", - "\n", - " def on_train_begin(self, logs=None):\n", - " \"\"\"Set the learning rate to the base_lr at the start of training.\"\"\"\n", - " logs = logs or {}\n", - " tf.keras.backend.set_value(self.model.optimizer.learning_rate, self.base_lr)\n", - "\n", - " def on_batch_end(self, batch, logs=None):\n", - " \"\"\"Update the learning rate after each batch.\"\"\"\n", - " self.iterations += 1\n", - " learning_rate = self.clr()\n", - " tf.keras.backend.set_value(self.model.optimizer.learning_rate, learning_rate)\n", - " self.history.setdefault('lr', []).append(learning_rate)\n", - "\n", - " # Optional: Print current learning rate for visibility\n", - " print(f\"Iteration {self.iterations}: Learning rate is {learning_rate:.6f}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "\n", - "h5_filename = '/home/da886/Final Electron counting project/Images and Labels/30KPadded_Mixed_5.h5' ### for more challenging train\n", - "\n", - "data_loader = DataLoader(h5_filename)\n", - "\n", - "images, centers = data_loader.load_data()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "l=np.random.randint(0,len(centers))\n", - "data_loader.plot_image_with_centers(l)\n", - "plt.imshow(images[l])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train Images: (24000, 64, 64), Train Midpoints: (24000, 1, 5, 2)\n", - "Validation Images: (6000, 64, 64), Validation Midpoints: (6000, 1, 5, 2)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-11 18:29:17.311809: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 79196 MB memory: -> device: 0, name: NVIDIA A100 80GB PCIe, pci bus id: 0000:45:00.0, compute capability: 8.0\n" - ] - } - ], - "source": [ - "# Normalize the data and split it into training and validation sets\n", - "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", - "\n", - "# Check the shape of the datasets\n", - "print(f'Train Images: {train_images.shape}, Train Midpoints: {train_midpoints.shape}')\n", - "print(f'Validation Images: {val_images.shape}, Validation Midpoints: {val_midpoints.shape}')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", - "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", - "\n", - "batch_size = 200\n", - "train_dataset = train_dataset.shuffle(buffer_size=2000, reshuffle_each_iteration=True).batch(batch_size)\n", - "val_dataset = val_dataset.shuffle(buffer_size=2000).batch(batch_size)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_transposed_images_with_midpoints(train_dataset, image_indices=[0, 1, 2, 3])" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# Initialize the ModelBuilder\n", - "model_builder = ModelBuilder()\n", - "\n", - "# Build the model\n", - "model = model_builder.build_model()\n", - "\n", - "# # Display the model architecture\n", - "# model.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "I0000 00:00:1726079234.656592 3543603 service.cc:146] XLA service 0x7f28a0002660 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", - "I0000 00:00:1726079234.656657 3543603 service.cc:154] StreamExecutor device (0): NVIDIA A100 80GB PCIe, Compute Capability 8.0\n", - "2024-09-11 18:27:14.719376: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", - "2024-09-11 18:27:15.007394: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m 34/120\u001b[0m \u001b[32m━━━━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━\u001b[0m \u001b[1m0s\u001b[0m 5ms/step" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "I0000 00:00:1726079236.469546 3543603 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m120/120\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 5ms/step\n", - "\u001b[1m30/30\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n" - ] - } - ], - "source": [ - "train_outputs = model_builder.model.predict(train_dataset)\n", - "val_outputs = model_builder.model.predict(val_dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((24000, 1, 5, 2), (6000, 1, 5, 2))" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "train_outputs.shape,val_outputs.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "120" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(train_dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# model_builder = ModelBuilder()\n", - "# dynamic_exponent_callback = DynamicExponentCallback(2, 1, 100)\n", - "# model_builder.compile_model(loss_function=dynamic_exponent_callback.custom_loss(2))\n", - "clr_callback = SimpleCyclicLR(base_lr=1e-7, max_lr=1e-2, step_size=120)\n", - "model_builder.compile_model(loss_function=tf.keras.losses.MeanSquaredError())\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'str' object has no attribute 'name'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[13], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel_builder\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m110\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43mcallbacks_list\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mclr_callback\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[5], line 71\u001b[0m, in \u001b[0;36mModelBuilder.train_model\u001b[0;34m(self, train_dataset, val_dataset, epochs, callbacks_list)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtrain_model\u001b[39m(\u001b[38;5;28mself\u001b[39m, train_dataset, val_dataset, epochs, callbacks_list):\n\u001b[0;32m---> 71\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mepochs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks_list\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 72\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m history\n", - "File \u001b[0;32m~/anaconda3/envs/sod/lib/python3.12/site-packages/keras/src/utils/traceback_utils.py:122\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 119\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m 120\u001b[0m \u001b[38;5;66;03m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m 121\u001b[0m \u001b[38;5;66;03m# `keras.config.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m--> 122\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 123\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n", - "Cell \u001b[0;32mIn[6], line 25\u001b[0m, in \u001b[0;36mSimpleCyclicLR.on_train_begin\u001b[0;34m(self, logs)\u001b[0m\n\u001b[1;32m 23\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Set the learning rate to the base_lr at the start of training.\"\"\"\u001b[39;00m\n\u001b[1;32m 24\u001b[0m logs \u001b[38;5;241m=\u001b[39m logs \u001b[38;5;129;01mor\u001b[39;00m {}\n\u001b[0;32m---> 25\u001b[0m \u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkeras\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackend\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_value\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlearning_rate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbase_lr\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mAttributeError\u001b[0m: 'str' object has no attribute 'name'" - ] - }, - { - "ename": "", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", - "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", - "\u001b[1;31mClick here for more info. \n", - "\u001b[1;31mView Jupyter log for further details." - ] - } - ], - "source": [ - "\n", - "history = model_builder.train_model(train_dataset, val_dataset, epochs=110,callbacks_list=[clr_callback])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [], - "source": [ - "model.save('mymodifiedresne34.keras')" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "\n", - "# Extract the losses from the history object\n", - "train_loss = history.history['loss']\n", - "val_loss = history.history['val_loss']\n", - "\n", - "\n", - "train_loss_x_midpoints = history.history.get('x_midpoints_reshape_loss', train_loss)\n", - "val_loss_x_midpoints = history.history.get('val_x_midpoints_reshape_loss', val_loss)\n", - "\n", - "plt.figure(figsize=(12, 6))\n", - "plt.subplot(1, 2,1)\n", - "plt.plot(train_loss_x_midpoints, label='Train Loss x_midpoints_reshape')\n", - "plt.plot(val_loss_x_midpoints, label='Validation Loss x_midpoints_reshape')\n", - "plt.xlabel('Epochs')\n", - "plt.yscale('log')\n", - "\n", - "plt.ylabel('Loss')\n", - "plt.title('Training and Validation Loss ')\n", - "plt.legend()\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing batch 1, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 4ms/step\n", - "Processing batch 2, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 3, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 4, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 5, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 6, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", - "Processing batch 7, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 8, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", - "Processing batch 9, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 10, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 11, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 12, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 13, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 14, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 2ms/step\n", - "Processing batch 15, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 16, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 17, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 18, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 19, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 20, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 21, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 22, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 23, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 24, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 25, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 26, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 4ms/step\n", - "Processing batch 27, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 28, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 29, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n", - "Processing batch 30, batch shape: (800, 64, 64)\n", - "\u001b[1m25/25\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-09-11 18:10:39.140143: I tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import tensorflow as tf\n", - "\n", - "# Define the function for visualizing midpoints\n", - "def visualize_midpoints(image, midpoints, title=\"Predicted Midpoint Visualization\"):\n", - " \"\"\"\n", - " Visualizes midpoints on an image without using a probability vector.\n", - "\n", - " Parameters:\n", - " - image: A 3D tensor representing the image.\n", - " - midpoints: A 2D tensor representing the midpoint coordinates (x, y).\n", - " - title: The title of the plot.\n", - "\n", - " Returns:\n", - " None (displays the image with midpoints).\n", - " \"\"\"\n", - " # Convert to NumPy arrays for easier handling\n", - " image_np = image\n", - " midpoints_np = midpoints\n", - "\n", - " # Denormalize image if necessary (adjust based on your normalization method)\n", - " denormalized_image = image_np # Modify if normalization was applied during training\n", - "\n", - " # Visualize the image\n", - " plt.figure(figsize=(4, 4))\n", - " plt.imshow(denormalized_image, cmap='gray')\n", - " plt.title(title)\n", - "\n", - " # Plot midpoints directly, only if they are not (0, 0)\n", - " for i, (x, y) in enumerate(midpoints_np):\n", - " if x >= 3 and y >= 3: # Only plot if the point is not (0, 0)\n", - " plt.scatter(x, y, color='red', s=5)\n", - "\n", - " plt.show()\n", - "\n", - "# Create the validation dataset\n", - "# val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_midpoints))\n", - "# val_dataset = val_dataset.batch(800)\n", - "train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_midpoints))\n", - "train_dataset = train_dataset.batch(800)\n", - "\n", - "# Initialize lists to collect the data\n", - "all_images = []\n", - "all_true_midpoints = []\n", - "all_pred_midpoints = []\n", - "\n", - "# Loop through each batch in the validation dataset, predict, and collect results\n", - "# for i, (data_batch, midpoints_batch) in enumerate(val_dataset):\n", - "\n", - "for i, (data_batch, midpoints_batch) in enumerate(train_dataset):\n", - " print(f\"Processing batch {i + 1}, batch shape: {data_batch.shape}\")\n", - " \n", - " # Get the model predictions\n", - " predictions = model_builder.model.predict(data_batch)\n", - "\n", - " # Extend the lists to store data from each batch\n", - " all_images.extend(data_batch.numpy()) # Store all images\n", - " all_true_midpoints.extend(midpoints_batch.numpy()) # Store all true midpoints\n", - " all_pred_midpoints.extend(predictions) # Store all predicted midpoints\n", - "\n", - "# Convert lists to arrays for easier indexing\n", - "all_images = np.array(all_images)\n", - "all_true_midpoints = np.array(all_true_midpoints)\n", - "all_pred_midpoints = np.array(all_pred_midpoints)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Select an index to visualize from the entire dataset\n", - "index_to_visualize = np.random.randint(0, len(all_images))\n", - "\n", - "# index_to_visualize = 11548\n", - "# Visualize the selected image with predicted and true midpoints\n", - "visualize_midpoints(all_images[index_to_visualize], all_pred_midpoints[index_to_visualize, 0, :, :] * 64, title=\"Predicted Midpoints\")\n", - "visualize_midpoints(all_images[index_to_visualize], all_true_midpoints[index_to_visualize, 0, :, :] * 64, title=\"Ground Truth Midpoints\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Initialize variables to track the min and max MSE\n", - "min_mse = float('inf')\n", - "max_mse = float('-inf')\n", - "min_mse_index = -1\n", - "max_mse_index = -1\n", - "\n", - "# Loop through each prediction to calculate the MSE\n", - "for i in range(len(all_pred_midpoints)):\n", - " mse = np.mean((all_pred_midpoints[i] - all_true_midpoints[i]) ** 2)\n", - " \n", - " if mse < min_mse:\n", - " min_mse = mse\n", - " min_mse_index = i\n", - " \n", - " if mse > max_mse:\n", - " max_mse = mse\n", - " max_mse_index = i\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Function to plot an image with its centers\n", - "def plot_image_with_centers(image, true_center, predicted_center, title):\n", - " plt.figure(figsize=(5, 5))\n", - " plt.imshow(image.squeeze(), cmap='gray') # Display the image\n", - "\n", - " # Plot the actual center (Groundtruth)\n", - " plt.scatter(true_center[:, 0], true_center[:, 1], color='green', label='Groundtruth', s=10)\n", - "\n", - " # Plot the predicted center\n", - " plt.scatter(predicted_center[:, 0], predicted_center[:, 1], color='red', label='Predictions', s=10)\n", - "\n", - " plt.title(title)\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "# Plotting the image with the least MSE\n", - "plot_image_with_centers(all_images[min_mse_index],\n", - " all_true_midpoints[min_mse_index][0] * 64, # Adjust for scaling if needed\n", - " all_pred_midpoints[min_mse_index][0] * 64, # Adjust for scaling if needed\n", - " f'Image with Least MSE. MSE: {min_mse:.4f}')\n", - "\n", - "# Plotting the image with the largest MSE\n", - "plot_image_with_centers(all_images[max_mse_index],\n", - " all_true_midpoints[max_mse_index][0] * 64, # Adjust for scaling if needed\n", - " all_pred_midpoints[max_mse_index][0] * 64, # Adjust for scaling if needed\n", - " f'Image with Largest MSE. MSE: {max_mse:.4f}')\n", - "\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "sod", - "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.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/YOLO/yolo in pytorch.ipynb b/YOLO/yolo in pytorch.ipynb new file mode 100644 index 0000000..c85913b --- /dev/null +++ b/YOLO/yolo in pytorch.ipynb @@ -0,0 +1,752 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py\n", + "import torch\n", + "from torch.utils.data import Dataset\n", + "import torch\n", + "import torch.nn as nn\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import sys\n", + "import sklearn" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# sys.path.append('/home/da886/yolov5/') # Replace with the actual path to the yolov5 directory\n", + "\n", + "# Set device IDs for multi-GPU usage\n", + "device_ids = [0, 1, 2]\n", + "import torch\n", + "import torchvision.transforms as transforms\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data Loader" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py\n", + "import numpy as np\n", + "import torch\n", + "from sklearn.model_selection import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class MyDataLoader:\n", + " def __init__(self, h5_filename):\n", + " self.h5_filename = h5_filename\n", + " self.images, self.centers = self.load_data()\n", + "\n", + " def load_data(self):\n", + " with h5py.File(self.h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " return images, centers\n", + "\n", + " def plot_image_with_centers(self, image_index=None):\n", + " # Randomly select an image if no index is provided\n", + " if image_index is None:\n", + " image_index = np.random.randint(0, len(self.images))\n", + "\n", + " image = self.images[image_index]\n", + " centers = self.centers[image_index]\n", + "\n", + " plt.imshow(image, cmap='gray')\n", + " valid_centers = centers[centers[:, 0] == 1] # Only plot valid centers\n", + " for center in valid_centers:\n", + " plt.scatter(center[1], center[2], c='red', marker='o', s=5) # center[1] is x, center[2] is y\n", + " plt.title('Image with Valid Centers Marked')\n", + " plt.colorbar()\n", + " plt.show()\n", + "\n", + " @staticmethod\n", + " def sort_centers(centers):\n", + " # Sort centers by their second and first columns (equivalent to x and y coordinates)\n", + " return centers[np.lexsort((centers[:, 0], centers[:, 1]))]\n", + "\n", + " def normalize_data(self):\n", + " # Normalize the images and centers\n", + " normalized_images = self.images / np.max(self.images)\n", + " sorted_centers = np.array([self.sort_centers(image_centers[:, 1:]) for image_centers in self.centers])\n", + " \n", + " # Normalize the centers by the max value\n", + " normalized_centers = sorted_centers / np.max(sorted_centers)\n", + "\n", + " # Convert normalized centers to torch tensor and add a new dimension for midpoints\n", + " normalized_midpoints = torch.tensor(normalized_centers).unsqueeze(1)\n", + " \n", + " return torch.tensor(normalized_images), normalized_midpoints\n", + "\n", + " def split_data(self, train_size=0.8, random_state=42):\n", + " # Normalize the data\n", + " normalized_images, normalized_midpoints = self.normalize_data()\n", + "\n", + " # Convert tensors to numpy for splitting\n", + " normalized_images_np = normalized_images.numpy()\n", + " normalized_midpoints_np = normalized_midpoints.numpy()\n", + "\n", + " # Split the data using train_test_split\n", + " return train_test_split(normalized_images_np, normalized_midpoints_np, train_size=train_size, random_state=random_state)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Example usage\n", + "dataset = MyDataLoader('/home/da886/Final Electron counting project/Images and Labels/12KFixed_Mixed_13_32by32_SparsespotsRandomIndex.h5')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(12000, 13, 3)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset.centers.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(dataset.images[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(12000, 32, 32)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset.images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "# from torch.utils.data import DataLoader\n", + "\n", + "# Initialize the dataset and DataLoader\n", + "data_loader = MyDataLoader('/home/da886/Final Electron counting project/Images and Labels/12KFixed_Mixed_13_32by32_SparsespotsRandomIndex.h5')\n", + "# train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True, num_workers=13)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Moder Definition" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "class ModelBuilder(nn.Module):\n", + " def __init__(self, input_shape=(1, 64, 64), num_classes=13, num_coordinates=2, learning_rate=1e-2, weights_path=None, l1_reg=0.001, l2_reg=0.01):\n", + " super(ModelBuilder, self).__init__()\n", + " self.input_shape = input_shape\n", + " self.num_classes = num_classes\n", + " self.num_coordinates = num_coordinates\n", + " self.learning_rate = learning_rate\n", + " self.l1_reg = l1_reg\n", + " self.l2_reg = l2_reg\n", + " \n", + " # Define the model layers\n", + " self.conv1 = nn.Conv2d(in_channels=input_shape[0], out_channels=64, kernel_size=3, padding=1)\n", + " self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1)\n", + " self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n", + " self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1)\n", + " self.conv5 = nn.Conv2d(128, 256, kernel_size=3, padding=1)\n", + " self.conv6 = nn.Conv2d(256, 256, kernel_size=3, padding=1)\n", + " self.conv7 = nn.Conv2d(256, 512, kernel_size=3, padding=1)\n", + " self.conv8 = nn.Conv2d(512, 512, kernel_size=3, padding=1)\n", + " self.conv9 = nn.Conv2d(512, 512, kernel_size=3, padding=1)\n", + " self.conv10 = nn.Conv2d(512, 256, kernel_size=5, padding=2)\n", + " \n", + " self.maxpool = nn.MaxPool2d(kernel_size=2)\n", + " # self.batchnorm = nn.BatchNorm2d(256)\n", + " \n", + " self.flatten = nn.Flatten()\n", + " self.fc = nn.Linear(256, num_classes * num_coordinates) \n", + " self.reshape = lambda x: x.view(-1, num_classes, num_coordinates) # Reshaping function\n", + " \n", + " # Define the optimizer\n", + " self.optimizer = optim.Adam(self.parameters(), lr=self.learning_rate)\n", + " \n", + " # Load weights if provided\n", + " if weights_path is not None:\n", + " self.load_state_dict(torch.load(weights_path))\n", + "\n", + " def forward(self, x):\n", + " x = torch.relu(self.conv1(x))\n", + " x = self.maxpool(x)\n", + " x = torch.relu(self.conv2(x))\n", + " \n", + " x = torch.relu(self.conv3(x))\n", + " x = torch.relu(self.conv4(x))\n", + " \n", + " x = torch.relu(self.conv5(x))\n", + " x = torch.relu(self.conv6(x))\n", + " \n", + " x = torch.relu(self.conv7(x))\n", + " x = self.maxpool(x)\n", + " x = torch.relu(self.conv8(x))\n", + " x = self.maxpool(x)\n", + " x = torch.relu(self.conv9(x))\n", + " x = self.maxpool(x)\n", + " \n", + " x = torch.relu(self.conv10(x))\n", + " x = self.maxpool(x)\n", + " # x = self.batchnorm(x)\n", + " \n", + " x = self.flatten(x)\n", + " x = self.fc(x)\n", + " x = self.reshape(x)\n", + " \n", + " return x\n", + " \n", + " def compile_model(self, loss_function):\n", + " self.loss_function = loss_function\n", + " \n", + " def train_model(self, train_loader, val_loader, epochs, device):\n", + " history = {'train_loss': [], 'val_loss': []}\n", + " for epoch in range(epochs):\n", + " self.train()\n", + " running_loss = 0.0\n", + " for data in train_loader:\n", + " inputs, labels = data\n", + " inputs, labels = inputs.to(device), labels.to(device)\n", + " \n", + " # Zero the parameter gradients\n", + " self.optimizer.zero_grad()\n", + " \n", + " # Forward pass\n", + " outputs = self(inputs)\n", + " loss = self.loss_function(outputs, labels)\n", + " \n", + " # Backward pass and optimization\n", + " loss.backward()\n", + " self.optimizer.step()\n", + " \n", + " running_loss += loss.item()\n", + " \n", + " # Validation\n", + " val_loss = 0.0\n", + " self.eval()\n", + " with torch.no_grad():\n", + " for data in val_loader:\n", + " inputs, labels = data\n", + " inputs, labels = inputs.to(device), labels.to(device)\n", + " outputs = self(inputs)\n", + " loss = self.loss_function(outputs, labels)\n", + " val_loss += loss.item()\n", + "\n", + " # Logging the loss\n", + " history['train_loss'].append(running_loss / len(train_loader))\n", + " history['val_loss'].append(val_loss / len(val_loader))\n", + "\n", + " print(f\"Epoch {epoch+1}/{epochs}, Train Loss: {running_loss / len(train_loader):.4f}, Val Loss: {val_loss / len(val_loader):.4f}\")\n", + " \n", + " return history\n" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [], + "source": [ + "model = ModelBuilder(input_shape=(1, 32, 32), num_classes=13, num_coordinates=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.utils.data import DataLoader, TensorDataset\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Assuming `data_loader` is an instance of the `DataLoader` class you defined\n", + "\n", + "# Normalize the data and split it into training and validation sets\n", + "train_images, val_images, train_midpoints, val_midpoints = data_loader.split_data()\n", + "\n", + "# Convert numpy arrays to PyTorch tensors\n", + "train_images_tensor = torch.tensor(train_images, dtype=torch.float32)\n", + "train_midpoints_tensor = torch.tensor(train_midpoints, dtype=torch.float32)\n", + "val_images_tensor = torch.tensor(val_images, dtype=torch.float32)\n", + "val_midpoints_tensor = torch.tensor(val_midpoints, dtype=torch.float32)\n", + "\n", + "# Create TensorDataset for training and validation sets\n", + "train_dataset = TensorDataset(train_images_tensor, train_midpoints_tensor)\n", + "val_dataset = TensorDataset(val_images_tensor, val_midpoints_tensor)\n", + "\n", + "# Define PyTorch DataLoaders for batch processing\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((9600, 32, 32),\n", + " torch.Size([9600, 32, 32]),\n", + " (9600, 1, 13, 2),\n", + " torch.Size([9600, 1, 13, 2]))" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images.shape,train_images_tensor.shape,train_midpoints.shape,train_midpoints_tensor.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(train_images_tensor[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAlMUlEQVR4nO3df3BU9f3v8ddJSFaUZGmEJKQECmpBi9Bvqaa5Wool5UfvOFDwjtrOFFtHRxqcKm1VOq3WtjPxqzNq2y/FudOptDNFrB2R0fmqVTRhbAMtVIZaa0ZoWvALCZUZdjGaTch+7h9et40Q2XeyHz5nw/MxszNm98PZ9zmf3X159px9n8g55wQAwGlWEroAAMCZiQACAARBAAEAgiCAAABBEEAAgCAIIABAEAQQACAIAggAEMSY0AW8Xzab1cGDB1VRUaEoikKXAwAwcs7p2LFjqqurU0nJ0Ps5sQuggwcPqr6+PnQZAIAROnDggCZPnjzk494CaN26dbrvvvvU1dWlOXPm6Cc/+YkuvfTSU/67iooKSdLl+t8aE5Xl92TF2k2opDT/sS5rW7bPbWKpW5KyA96WHZXl/xJ2mYxx2eX5Dy4x7q1nbfPj+vvyHhslErZlW7aL9VsJy+vQOvel+Y+3bL93F+5xPePEss0N7+Pj6tdL+u/c5/lQvATQo48+qjVr1uihhx5SQ0ODHnzwQS1atEgdHR2qrq7+wH/73tduY6Ky/ANIRTr5keUNZwwgn9vEVLekyHCo0bjsKDIEUGTbhlHerz/ZP7AiYwAZxpvqlnG7mL8WN6ynee4NAWTc3l7XM04s29zyPv7/m+NUh1G8nIRw//3364YbbtBXvvIVXXTRRXrooYd09tln6+c//7mPpwMAFKGCB1BfX5927dqlpqamfz1JSYmamprU3t5+wvhMJqN0Oj3oBgAY/QoeQG+++aYGBgZUU1Mz6P6amhp1dXWdML6lpUXJZDJ34wQEADgzBP8d0Nq1a5VKpXK3AwcOhC4JAHAaFPwkhAkTJqi0tFTd3d2D7u/u7lZtbe0J4xOJhBLGs3YAAMWv4HtA5eXlmjt3rrZu3Zq7L5vNauvWrWpsbCz00wEAipSX07DXrFmjlStX6pOf/KQuvfRSPfjgg+rp6dFXvvIVH08HAChCXgLo6quv1j//+U/deeed6urq0sc//nE988wzJ5yYAAA4c0XOxesnvOl0WslkUvO11PBDVI88/VLYLE598eL0krFsl2LtDmFdfpy6ZhSrYu2EEJNOFcddv1qzjyuVSqmysnLoReb/7AAAFA4BBAAIggACAARBAAEAgiCAAABBEEAAgCAIIABAEAQQACAIAggAEAQBBAAIwksvuFHF2tbEICorz7+M4/22ZY/Jv42R6+8zLdtnWyBL3dIwajeIxuT/9nDHjxsXbtyGPts8WVhbDlnEZR0le2ud2LTssu5TGD7fLJ+FeY5lDwgAEAQBBAAIggACAARBAAEAgiCAAABBEEAAgCAIIABAEAQQACAIAggAEAQBBAAIggACAARBL7hT8NpTzcLYm8pUi7W/l7WXlWH5Xrehkcvmv81LzjrLtOxsb69pvKlvoNfXobE3orWnWrGKUx+7IsIeEAAgCAIIABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgCAIIABDE6GjFE0X5j/XZ0sYoNm1nfLcRsSzfMpfy3CrJUHe21+82jM1r5UxprWN8HZq2i8/WVx7bZJmWnef2YA8IABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgCAIIABAEAQQACIIAAgAEMTp6wfnkq1eS5LWHnYm1N5XLGscbavfZq8/a38tUiHF+jNs8Ksm/dpc11mJ43UZl5aZFuwGPPfJ89jD0+X4z1h2Nyf9j2ufc+8AeEAAgiIIH0Pe+9z1FUTToNnPmzEI/DQCgyHn5Cu5jH/uYnn/++X89iWEXEgBwZvCSDGPGjFFtba2PRQMARgkvx4Bef/111dXVafr06frSl76k/fv3Dzk2k8konU4PugEARr+CB1BDQ4M2bNigZ555RuvXr1dnZ6c+/elP69ixYycd39LSomQymbvV19cXuiQAQAxFzvm9xu7Ro0c1depU3X///br++utPeDyTySiTyeT+TqfTqq+v13wt1Zgoz8st+zydmdOwT+TzNGyfOA375DgNO9aK8TTs465frdqiVCqlysrKIcd5Pztg/Pjx+uhHP6q9e/ee9PFEIqFEIuG7DABAzHj/HdBbb72lffv2adKkSb6fCgBQRAoeQN/85jfV1tamv//97/r973+vL3zhCyotLdW1115b6KcCABSxgn8F98Ybb+jaa6/VkSNHNHHiRF1++eXavn27Jk6cWOin+pfIkKPO+J2n5ftxj793csePe1u2WVyO6Vh5rNs699b5tB5288XU+ihOjMf/nv2fl03jF334P/IfbG03Faf3foEV/BNz06ZNhV4kAGAUohccACAIAggAEAQBBAAIggACAARBAAEAgiCAAABBEEAAgCAIIABAEAQQACAIAggAEIT3yzGcDrZrpfiro2h7NhXzdVVick0l33NvuiaMtRbDNoxKbdcxMl0PyDo/Hud+Ud3HbbXIsHzrdani0nvRcg0rl5Xy+KxlDwgAEAQBBAAIggACAARBAAEAgiCAAABBEEAAgCAIIABAEAQQACAIAggAEAQBBAAIIr6teKIo75YVXtugWNqUjCkzLdr191mryZ+lbUaMWvFYWs5Ixrkv1hYoMRKrdlOR4f+fnefXeExaQnll6WOW51j2gAAAQRBAAIAgCCAAQBAEEAAgCAIIABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAx7gVXkn+vJ0OfJ5+9xtzxftOyvYpRfzeLWPUaixGv28Vjb7KorDz/Mqy9EeP0GrdsQ2tPQl91+Fx2nmPZAwIABEEAAQCCIIAAAEEQQACAIAggAEAQBBAAIAgCCAAQBAEEAAiCAAIABEEAAQCCIIAAAEHEtxecy0rKFn6xA7b+UdnP/EfeY0vaXrYVY+gJFZWWmhZdrD3VokTCNN5lMobBxj5ZJYZt7oyvVWstlv5hPvuBGfuYmfu7WVjmx3ffOJ/zY3odGtfTUne+vTmld98Pebwl2AMCAARhDqBt27bpyiuvVF1dnaIo0hNPPDHoceec7rzzTk2aNEljx45VU1OTXn/99ULVCwAYJcwB1NPTozlz5mjdunUnffzee+/Vj3/8Yz300EPasWOHzjnnHC1atEi9vb0jLhYAMHqYjwEtWbJES5YsOeljzjk9+OCD+s53vqOlS5dKkn75y1+qpqZGTzzxhK655pqRVQsAGDUKegyos7NTXV1dampqyt2XTCbV0NCg9vb2k/6bTCajdDo96AYAGP0KGkBdXV2SpJqamkH319TU5B57v5aWFiWTydytvr6+kCUBAGIq+Flwa9euVSqVyt0OHDgQuiQAwGlQ0ACqra2VJHV3dw+6v7u7O/fY+yUSCVVWVg66AQBGv4IG0LRp01RbW6utW7fm7kun09qxY4caGxsL+VQAgCJnPgvurbfe0t69e3N/d3Z2avfu3aqqqtKUKVN0yy236Ic//KEuuOACTZs2Td/97ndVV1enZcuWFbJuAECRMwfQzp07dcUVV+T+XrNmjSRp5cqV2rBhg2677Tb19PToxhtv1NGjR3X55ZfrmWee0VlnnWV7Iuck5dmywmMbjDcvHpv32OpttjYlllpc1mN7lRgxtdbxzdK+xdiixjz+TGDdJr7b61j4bH/k83VoqdvS5ifPsZFzPrecXTqdVjKZ1Hwt1ZioLL9/5DGADq/+X3mPrV538lPNC1KLpR+UFK8355kgToESo15wplp8LvtMEZNteNz1q1VblEqlPvC4fvCz4AAAZyYCCAAQBAEEAAiCAAIABEEAAQCCIIAAAEEQQACAIAggAEAQBBAAIAgCCAAQhLkXXCx5bMlR/V+/97ZskzOltU6cWg5ZarHWYVzPqNQw3mVNy3bHjxsGG99rHttkeVWsLYfitA3zwB4QACAIAggAEAQBBAAIggACAARBAAEAgiCAAABBEEAAgCAIIABAEAQQACAIAggAEER8W/FEUf4tK4qs/USOte2MhaU1jM/WINblG1vaRGPyfwmbWs5I5pY2JubWPflvQ/N6+uTzvWl5/1jn0li36XU44LF9lO/3coGxBwQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgCAIIABAEAQQACIIAAgAEQQABAIKIby845yQVaY83H6y9rHz2ybLy2G/K0lfL0q9LildPNVMt1h6Dhr50PrfhGTM/PhVZX0z2gAAAQRBAAIAgCCAAQBAEEAAgCAIIABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAg4tuKJy6iKP+x1jYYhhYoZi4e7VWsfNZiadvjW5y2uYW5DkNboDjNj5lhPaMSw2eKjNvFZysea3uvPDp8sQcEAAiCAAIABGEOoG3btunKK69UXV2doijSE088Mejx6667TlEUDbotXry4UPUCAEYJcwD19PRozpw5Wrdu3ZBjFi9erEOHDuVujzzyyIiKBACMPuaTEJYsWaIlS5Z84JhEIqHa2tphFwUAGP28HANqbW1VdXW1ZsyYoVWrVunIkSNDjs1kMkqn04NuAIDRr+ABtHjxYv3yl7/U1q1b9Z//+Z9qa2vTkiVLNDDEqYQtLS1KJpO5W319faFLAgDEUOTc8E8cj6JImzdv1rJly4Yc87e//U3nnXeenn/+eS1YsOCExzOZjDKZTO7vdDqt+vp6zddSjYnKhlta4fj8HVBMxOk3KV5rscyl5HU+va6nx0tym/m8NHyc3m/8DmiQ465frdnHlUqlVFlZOfQiC1HXB5k+fbomTJigvXv3nvTxRCKhysrKQTcAwOjnPYDeeOMNHTlyRJMmTfL9VACAImI+C+6tt94atDfT2dmp3bt3q6qqSlVVVbr77ru1YsUK1dbWat++fbrtttt0/vnna9GiRQUtHABQ3MwBtHPnTl1xxRW5v9esWSNJWrlypdavX689e/boF7/4hY4ePaq6ujotXLhQP/jBD5RIJGxPVFIqRcbvsvNh/b47yn8nMRpjq9f199lqMYgM29v1+avDyms/MOv34x6P/3nt7ebzmI6V5bhOnI7pWJmOXxk/1wzbxXxs0fJ+s7yu8uxFaQ6g+fPn64POW3j22WetiwQAnIHoBQcACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgCAIIABAEAQQACIIAAgAEYW7Fc9pkB/Luw2bqf1Ti7zoszno9E4/cv11j6ZSs18nxeF2dqNTYT88wP1FZuWnZtjr6jf+gSPuexeiaSrFiWU9Df8l3x+e/zb32GPSAPSAAQBAEEAAgCAIIABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgiPi24jHw2n7C0nrE2nbE57ItYtQuxWWNtZTk37rH9fcZqzGwtqjxyNSaSsb3j/G1EiUS+S+6zzg/MXrdWriBAeM/iMl6Gt5rclkpj85k7AEBAIIggAAAQRBAAIAgCCAAQBAEEAAgCAIIABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAgRkUvOFOPoqzHPkzWfmBxWbaVsZao1NCvzWdfPyuf/d18bkNjr7GorNzbsl0mYyjE4/a2fEZI9s8JC5dHk7TTxdSP0lB3nmPZAwIABEEAAQCCIIAAAEEQQACAIAggAEAQBBAAIAgCCAAQBAEEAAiCAAIABEEAAQCCGB2teCxtM7y2y7HleVSafy3WFjVRIpH/4KytbY/r77ON99lex9RKxNieyGM7o2iM7a3ncxta57Mo+WytY2V9XRXjazzP5bIHBAAIwhRALS0tuuSSS1RRUaHq6motW7ZMHR0dg8b09vaqublZ5557rsaNG6cVK1aou7u7oEUDAIqfKYDa2trU3Nys7du367nnnlN/f78WLlyonp6e3Jhbb71VTz75pB577DG1tbXp4MGDWr58ecELBwAUt8i54X8J+M9//lPV1dVqa2vTvHnzlEqlNHHiRG3cuFFXXXWVJOm1117ThRdeqPb2dn3qU5865TLT6bSSyaTma6nGRGXDLW1oPo8BGVu+RyVnxjEgr3x+P+5RnI4BxUacLjkSJ0X4Gj/u+tWqLUqlUqqsrBxy3IiOAaVSKUlSVVWVJGnXrl3q7+9XU1NTbszMmTM1ZcoUtbe3n3QZmUxG6XR60A0AMPoNO4Cy2axuueUWXXbZZZo1a5YkqaurS+Xl5Ro/fvygsTU1Nerq6jrpclpaWpRMJnO3+vr64ZYEACgiww6g5uZmvfLKK9q0adOICli7dq1SqVTuduDAgREtDwBQHIb1O6DVq1frqaee0rZt2zR58uTc/bW1terr69PRo0cH7QV1d3ertrb2pMtKJBJKWI5XAABGBdMekHNOq1ev1ubNm/XCCy9o2rRpgx6fO3euysrKtHXr1tx9HR0d2r9/vxobGwtTMQBgVDDtATU3N2vjxo3asmWLKioqcsd1ksmkxo4dq2Qyqeuvv15r1qxRVVWVKisrdfPNN6uxsTGvM+AAAGcOUwCtX79ekjR//vxB9z/88MO67rrrJEkPPPCASkpKtGLFCmUyGS1atEg//elPC1IsAGD0GNHvgHx473dAV5T9n7x/B2T6XYrxtzqWHlJv3mj7mnHC/z35qenwo+Sss0zjs729eY89Y37XY/2tjkW8PoowAqfld0AAAAwXAQQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgCAIIABAEAQQACGJYl2M4HVx/n1xU+NYclstgS5LL5j92wp4eWzGWtkCGlkDmZVtWUrK3TDG0b4lKba2SLC1tLK11rIq2tY5VsbbLidHlvs1tmwYM731j3QPzP5H32P/5TP6trAZ6e6V7tpxyHHtAAIAgCCAAQBAEEAAgCAIIABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgiNj2gvPF3LPL0kNq+x7bsi392qwsveOsdThjXzqfLPPjsYdd0fZI882yDSPj/w9b+yPGhNfPIKPS1j/lPXbKtvw/J467fu3LYxx7QACAIAggAEAQBBAAIAgCCAAQBAEEAAiCAAIABEEAAQCCIIAAAEEQQACAIAggAEAQ8W3FE0X5t6CwtPCwtu/w2WIlLq1EPNcRlebfwsPcpsTSRihOLYTM7Y+y+Y+NU0sby/vHOj9xapVkmc84fQZZWOrOcy7ZAwIABEEAAQCCIIAAAEEQQACAIAggAEAQBBAAIAgCCAAQBAEEAAiCAAIABEEAAQCCIIAAAEHEtxecc5Ly7IEUkx5fUVm5abzr7/NUSbyY+7tZGPpTRWOML3dDTzV3vN+2bCtTPzBD37hiZul55/kzIiox9KUrsb0Ovb5/AmMPCAAQhCmAWlpadMkll6iiokLV1dVatmyZOjo6Bo2ZP3++oigadLvpppsKWjQAoPiZAqitrU3Nzc3avn27nnvuOfX392vhwoXq6ekZNO6GG27QoUOHcrd77723oEUDAIqf6cvIZ555ZtDfGzZsUHV1tXbt2qV58+bl7j/77LNVW1tbmAoBAKPSiI4BpVIpSVJVVdWg+3/1q19pwoQJmjVrltauXau33357yGVkMhml0+lBNwDA6Dfss+Cy2axuueUWXXbZZZo1a1bu/i9+8YuaOnWq6urqtGfPHt1+++3q6OjQ448/ftLltLS06O677x5uGQCAIhU5N7zrva5atUpPP/20XnrpJU2ePHnIcS+88IIWLFigvXv36rzzzjvh8Uwmo0wmk/s7nU6rvr5e87VUY6Ky4ZQWDKdhx1usTsP2edlsy6Wqpfhc8tnK52WwjcyvLYNiPA37uOtXq7YolUqpsrJyyHHD2mqrV6/WU089pW3btn1g+EhSQ0ODJA0ZQIlEQolEYjhlAACKmCmAnHO6+eabtXnzZrW2tmratGmn/De7d++WJE2aNGlYBQIARidTADU3N2vjxo3asmWLKioq1NXVJUlKJpMaO3as9u3bp40bN+rzn/+8zj33XO3Zs0e33nqr5s2bp9mzZ3tZAQBAcTIF0Pr16yW9+2PTf/fwww/ruuuuU3l5uZ5//nk9+OCD6unpUX19vVasWKHvfOc7BSsYADA6mL+C+yD19fVqa2sbUUHFLE4nFZhOiHC23mGxOihqOBDtBowHop3H9fTZm6xYTyqw8nxigYXlPeHzhAXTiRlS8G1ILzgAQBAEEAAgCAIIABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgCI89IUYoivK/roml9UiRtap4j7l9h6G9Tqxa61j5nJ84XW/G0FopTi2hTNcmKuYWQpaWUFnbelre+9b3ss9l54M9IABAEAQQACAIAggAEAQBBAAIggACAARBAAEAgiCAAABBEEAAgCAIIABAEAQQACAIAggAEER8e8E5J8lDbyhDjzTvDH2yzH2YLD24cHKW/m7W7W3se+azv5vXfmBx6e8Wpx6QxmX7/MgK3QeSPSAAQBAEEAAgCAIIABAEAQQACIIAAgAEQQABAIIggAAAQRBAAIAgCCAAQBAEEAAgiPi24omi/NubWNp9WFuDWFp4WNt3WGqxthLx2b/Dc9sZi6isPP8yPLazUWT9fznb/ESl+c+/tb2K13YslteKdRta3m8+W+ucjuX7YvlcMX2mRHl1UmMPCAAQBAEEAAiCAAIABEEAAQCCIIAAAEEQQACAIAggAEAQBBAAIAgCCAAQBAEEAAiCAAIABBHjXnAl+feGch77MBVpjydT77ABjz3sPPPa381nH0Aj8xxZWPq1Wefe1KexON9rcRKNsX2km15XHnpusgcEAAjCFEDr16/X7NmzVVlZqcrKSjU2Nurpp5/OPd7b26vm5made+65GjdunFasWKHu7u6CFw0AKH6mAJo8ebLuuece7dq1Szt37tRnP/tZLV26VH/5y18kSbfeequefPJJPfbYY2pra9PBgwe1fPlyL4UDAIpb5NzIvtCvqqrSfffdp6uuukoTJ07Uxo0bddVVV0mSXnvtNV144YVqb2/Xpz71qbyWl06nlUwmNb9kucZEZfkVUaTHaUyM1wOKSvL/Xr+YjwF5FaNjQF6P0/hcNk6ruBwDOu761aotSqVSqqysHHLcsI8BDQwMaNOmTerp6VFjY6N27dql/v5+NTU15cbMnDlTU6ZMUXt7+5DLyWQySqfTg24AgNHPHEB//vOfNW7cOCUSCd10003avHmzLrroInV1dam8vFzjx48fNL6mpkZdXV1DLq+lpUXJZDJ3q6+vN68EAKD4mANoxowZ2r17t3bs2KFVq1Zp5cqVevXVV4ddwNq1a5VKpXK3AwcODHtZAIDiYf4dUHl5uc4//3xJ0ty5c/XHP/5RP/rRj3T11Verr69PR48eHbQX1N3drdra2iGXl0gklEgk7JUDAIraiH8HlM1mlclkNHfuXJWVlWnr1q25xzo6OrR//341NjaO9GkAAKOMaQ9o7dq1WrJkiaZMmaJjx45p48aNam1t1bPPPqtkMqnrr79ea9asUVVVlSorK3XzzTersbEx7zPgAABnDlMAHT58WF/+8pd16NAhJZNJzZ49W88++6w+97nPSZIeeOABlZSUaMWKFcpkMlq0aJF++tOfDq+y7ED+rXjiwniqtFzWz1hJ7rjhdFnLabjDUaSnEJeU5/kzAEnZjG1+vJ7ObJ1Pn7VY3hPG1zinhJ/IHT8eugSTEf8OqNByvwPS0vx/BxQXPgPIyjKtvj+wijWAzjor77HZTMa0bK/raUUAocC8/w4IAICRIIAAAEEQQACAIAggAEAQBBAAIAgCCAAQBAEEAAiCAAIABEEAAQCCMHfD9u29xgzH1S8V2w+dzb/kjkknBPlu3eLzipseOyG4/P//LOv6Tcv2up5WPjsKeGw3RSeE+Dqud98Pp2q0E7sAOnbsmCTpJf134EqGwWOeeOX7fexz+T6X3etx2VbF+llbrO8JFMSxY8eUTCaHfDx2veCy2awOHjyoiooKRf/W/yqdTqu+vl4HDhz4wN5CxY71HD3OhHWUWM/RphDr6ZzTsWPHVFdXp5KSob9JiN0eUElJiSZPnjzk45WVlaN68t/Deo4eZ8I6SqznaDPS9fygPZ/3cBICACAIAggAEETRBFAikdBdd92lRCIRuhSvWM/R40xYR4n1HG1O53rG7iQEAMCZoWj2gAAAowsBBAAIggACAARBAAEAgiiaAFq3bp0+8pGP6KyzzlJDQ4P+8Ic/hC6poL73ve8piqJBt5kzZ4Yua0S2bdumK6+8UnV1dYqiSE888cSgx51zuvPOOzVp0iSNHTtWTU1Nev3118MUOwKnWs/rrrvuhLldvHhxmGKHqaWlRZdccokqKipUXV2tZcuWqaOjY9CY3t5eNTc369xzz9W4ceO0YsUKdXd3B6p4ePJZz/nz558wnzfddFOgiodn/fr1mj17du7Hpo2NjXr66adzj5+uuSyKAHr00Ue1Zs0a3XXXXfrTn/6kOXPmaNGiRTp8+HDo0grqYx/7mA4dOpS7vfTSS6FLGpGenh7NmTNH69atO+nj9957r3784x/roYce0o4dO3TOOedo0aJF6u2NUxO2UzvVekrS4sWLB83tI488chorHLm2tjY1Nzdr+/bteu6559Tf36+FCxeqp6cnN+bWW2/Vk08+qccee0xtbW06ePCgli9fHrBqu3zWU5JuuOGGQfN57733Bqp4eCZPnqx77rlHu3bt0s6dO/XZz35WS5cu1V/+8hdJp3EuXRG49NJLXXNzc+7vgYEBV1dX51paWgJWVVh33XWXmzNnTugyvJHkNm/enPs7m8262tpad9999+XuO3r0qEskEu6RRx4JUGFhvH89nXNu5cqVbunSpUHq8eXw4cNOkmtra3POvTt3ZWVl7rHHHsuN+etf/+okufb29lBljtj719M55z7zmc+4r3/96+GK8uRDH/qQ+9nPfnZa5zL2e0B9fX3atWuXmpqacveVlJSoqalJ7e3tASsrvNdff111dXWaPn26vvSlL2n//v2hS/Kms7NTXV1dg+Y1mUyqoaFh1M2rJLW2tqq6ulozZszQqlWrdOTIkdAljUgqlZIkVVVVSZJ27dql/v7+QfM5c+ZMTZkypajn8/3r+Z5f/epXmjBhgmbNmqW1a9fq7bffDlFeQQwMDGjTpk3q6elRY2PjaZ3L2DUjfb8333xTAwMDqqmpGXR/TU2NXnvttUBVFV5DQ4M2bNigGTNm6NChQ7r77rv16U9/Wq+88ooqKipCl1dwXV1dknTSeX3vsdFi8eLFWr58uaZNm6Z9+/bp29/+tpYsWaL29naVlpaGLs8sm83qlltu0WWXXaZZs2ZJenc+y8vLNX78+EFji3k+T7aekvTFL35RU6dOVV1dnfbs2aPbb79dHR0devzxxwNWa/fnP/9ZjY2N6u3t1bhx47R582ZddNFF2r1792mby9gH0JliyZIluf+ePXu2GhoaNHXqVP3617/W9ddfH7AyjNQ111yT+++LL75Ys2fP1nnnnafW1lYtWLAgYGXD09zcrFdeeaXoj1GeylDreeONN+b+++KLL9akSZO0YMEC7du3T+edd97pLnPYZsyYod27dyuVSuk3v/mNVq5cqba2ttNaQ+y/gpswYYJKS0tPOAOju7tbtbW1garyb/z48froRz+qvXv3hi7Fi/fm7kybV0maPn26JkyYUJRzu3r1aj311FN68cUXB102pba2Vn19fTp69Oig8cU6n0Ot58k0NDRIUtHNZ3l5uc4//3zNnTtXLS0tmjNnjn70ox+d1rmMfQCVl5dr7ty52rp1a+6+bDarrVu3qrGxMWBlfr311lvat2+fJk2aFLoUL6ZNm6ba2tpB85pOp7Vjx45RPa+S9MYbb+jIkSNFNbfOOa1evVqbN2/WCy+8oGnTpg16fO7cuSorKxs0nx0dHdq/f39Rzeep1vNkdu/eLUlFNZ8nk81mlclkTu9cFvSUBk82bdrkEomE27Bhg3v11VfdjTfe6MaPH++6urpCl1Yw3/jGN1xra6vr7Ox0v/vd71xTU5ObMGGCO3z4cOjShu3YsWPu5Zdfdi+//LKT5O6//3738ssvu3/84x/OOefuueceN378eLdlyxa3Z88et3TpUjdt2jT3zjvvBK7c5oPW89ixY+6b3/yma29vd52dne755593n/jEJ9wFF1zgent7Q5eet1WrVrlkMulaW1vdoUOHcre33347N+amm25yU6ZMcS+88ILbuXOna2xsdI2NjQGrtjvVeu7du9d9//vfdzt37nSdnZ1uy5Ytbvr06W7evHmBK7e54447XFtbm+vs7HR79uxxd9xxh4uiyP32t791zp2+uSyKAHLOuZ/85CduypQprry83F166aVu+/btoUsqqKuvvtpNmjTJlZeXuw9/+MPu6quvdnv37g1d1oi8+OKLTtIJt5UrVzrn3j0V+7vf/a6rqalxiUTCLViwwHV0dIQtehg+aD3ffvttt3DhQjdx4kRXVlbmpk6d6m644Yai+5+nk62fJPfwww/nxrzzzjvua1/7mvvQhz7kzj77bPeFL3zBHTp0KFzRw3Cq9dy/f7+bN2+eq6qqcolEwp1//vnuW9/6lkulUmELN/rqV7/qpk6d6srLy93EiRPdggULcuHj3OmbSy7HAAAIIvbHgAAAoxMBBAAIggACAARBAAEAgiCAAABBEEAAgCAIIABAEAQQACAIAggAEAQBBAAIggACAARBAAEAgvh/ZTde/IEsQBwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(train_images[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([32, 32])" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_images_tensor[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ModelBuilder(\n", + " (conv1): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv5): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv6): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv7): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv8): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv9): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv10): Conv2d(512, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", + " (maxpool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (fc): Linear(in_features=256, out_features=26, bias=True)\n", + ")" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([9600, 13, 2])" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output = model(train_images_tensor.unsqueeze(1))\n", + "output.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([9600, 1, 13, 2])" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_midpoints_tensor.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(0.3295, grad_fn=)" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "criterion = nn.MSELoss()\n", + "loss = criterion(output.unsqueeze(1), train_midpoints_tensor)\n", + "loss\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "# Define the optimizer (Adam or SGD)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "# Optionally, define a learning rate scheduler\n", + "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([16, 1, 32, 32]) torch.Size([16, 13, 3])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import matplotlib.pyplot as plt\n", + "batch = next(iter(train_loader))\n", + "images, labels = batch\n", + "print(images.shape, labels.shape)\n", + "plt.imshow(images[0].squeeze().numpy(), cmap='gray')\n", + "plt.title('Center: {}'.format(labels[0].numpy()))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Get a batch from the DataLoader\n", + "batch = next(iter(train_loader))\n", + "images, labels = batch\n", + "\n", + "# Display the first image in the batch\n", + "plt.imshow(images[0].squeeze().numpy(), cmap='gray')\n", + "\n", + "# Extract the label information (assuming labels are in the format [class_id, x_center, y_center])\n", + "centers = labels[0].numpy()[:, 1:] # Extract only the x_center, y_center (ignore class_id)\n", + "\n", + "# Plot the center points on the image\n", + "for center in centers:\n", + " x, y = center\n", + " plt.scatter(x, y, color='red', s=15) # Plot the center with red color\n", + "\n", + "plt.title('Center Coordinates')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [], + "source": [ + "model.compile_model(nn.MSELoss())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ModelBuilder(\n", + " (conv1): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv5): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv6): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv7): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv8): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv9): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv10): Conv2d(512, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", + " (maxpool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (fc): Linear(in_features=256, out_features=26, bias=True)\n", + " (loss_function): MSELoss()\n", + ")" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "model.to(device) " + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Given groups=1, weight of size [64, 1, 3, 3], expected input[1, 32, 32, 32] to have 1 channels, but got 32 channels instead", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[110], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[103], line 85\u001b[0m, in \u001b[0;36mModelBuilder.train_model\u001b[0;34m(self, train_loader, val_loader, epochs, device)\u001b[0m\n\u001b[1;32m 82\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptimizer\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m 84\u001b[0m \u001b[38;5;66;03m# Forward pass\u001b[39;00m\n\u001b[0;32m---> 85\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 86\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloss_function(outputs, labels)\n\u001b[1;32m 88\u001b[0m \u001b[38;5;66;03m# Backward pass and optimization\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/Yolo5/lib/python3.9/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1734\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/Yolo5/lib/python3.9/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1745\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1746\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n", + "Cell \u001b[0;32mIn[103], line 42\u001b[0m, in \u001b[0;36mModelBuilder.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[0;32m---> 42\u001b[0m x \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mrelu(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconv1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 43\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmaxpool(x)\n\u001b[1;32m 44\u001b[0m x \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mrelu(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconv2(x))\n", + "File \u001b[0;32m~/anaconda3/envs/Yolo5/lib/python3.9/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1734\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/Yolo5/lib/python3.9/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1745\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1746\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n", + "File \u001b[0;32m~/anaconda3/envs/Yolo5/lib/python3.9/site-packages/torch/nn/modules/conv.py:554\u001b[0m, in \u001b[0;36mConv2d.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 553\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 554\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_conv_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/anaconda3/envs/Yolo5/lib/python3.9/site-packages/torch/nn/modules/conv.py:549\u001b[0m, in \u001b[0;36mConv2d._conv_forward\u001b[0;34m(self, input, weight, bias)\u001b[0m\n\u001b[1;32m 537\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding_mode \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mzeros\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 538\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m F\u001b[38;5;241m.\u001b[39mconv2d(\n\u001b[1;32m 539\u001b[0m F\u001b[38;5;241m.\u001b[39mpad(\n\u001b[1;32m 540\u001b[0m \u001b[38;5;28minput\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_reversed_padding_repeated_twice, mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding_mode\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 547\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgroups,\n\u001b[1;32m 548\u001b[0m )\n\u001b[0;32m--> 549\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconv2d\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 550\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpadding\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdilation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgroups\u001b[49m\n\u001b[1;32m 551\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mRuntimeError\u001b[0m: Given groups=1, weight of size [64, 1, 3, 3], expected input[1, 32, 32, 32] to have 1 channels, but got 32 channels instead" + ] + } + ], + "source": [ + "history = model.train_model(train_loader, val_loader, 10, device)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Yolo5", + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/myDETR/Untitled-1.ipynb b/myDETR/Untitled-1.ipynb new file mode 100644 index 0000000..7ec53b1 --- /dev/null +++ b/myDETR/Untitled-1.ipynb @@ -0,0 +1,581 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Detected boxes:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done!\n" + ] + } + ], + "source": [ + "import torch\n", + "import argparse\n", + "import numpy as np\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import torchvision.transforms as T\n", + "\n", + "######################################################\n", + "# 1) PyTorch 2.6+ checkpoint fix\n", + "######################################################\n", + "# If your checkpoint includes `argparse.Namespace`, you can:\n", + "# (A) load with weights_only=False, or\n", + "# (B) allowlist Namespace\n", + "from argparse import Namespace\n", + "torch.serialization.add_safe_globals([Namespace])\n", + "# or if you prefer: checkpoint = torch.load(..., weights_only=False)\n", + "\n", + "######################################################\n", + "# 2) Import your DETR building code\n", + "######################################################\n", + "from detr.models import build_model # Adjust the import path if needed\n", + "\n", + "def get_inference_model(checkpoint_path):\n", + " parser = argparse.ArgumentParser()\n", + " args = parser.parse_args(args=[])\n", + "\n", + " # 1) Copy the defaults from your training script:\n", + " args.set_cost_class = 1\n", + " args.set_cost_bbox = 5\n", + " args.set_cost_giou = 2\n", + " args.mask_loss_coef = 1\n", + " args.dice_loss_coef = 1\n", + " args.bbox_loss_coef = 5\n", + " args.giou_loss_coef = 2\n", + " args.eos_coef = 0.1\n", + "\n", + " # 2) Also include these:\n", + " args.lr_backbone = 1e-5\n", + " args.lr = 1e-4\n", + " args.weight_decay = 1e-4\n", + " args.epochs = 300\n", + " args.lr_drop = 200\n", + "\n", + " # 3) For dataset & device:\n", + " args.device = \"cuda\"\n", + " args.dataset_file = \"coco\"\n", + " args.num_classes = 91 # single-class + background\n", + "\n", + " # 4) For backbone & transformer:\n", + " args.backbone = 'resnet50'\n", + " args.dilation = False\n", + " args.position_embedding = 'sine'\n", + " args.masks = False\n", + " args.enc_layers = 6\n", + " args.dec_layers = 6\n", + " args.dim_feedforward = 2048\n", + " args.hidden_dim = 256\n", + " args.dropout = 0.1\n", + " args.nheads = 8\n", + " args.num_queries = 100\n", + " args.pre_norm = False\n", + " args.aux_loss = True\n", + "\n", + " # 5) Build the DETR model\n", + " model, criterion, postprocessors = build_model(args)\n", + " model.eval()\n", + "\n", + " # 6) Load checkpoint\n", + " checkpoint = torch.load(checkpoint_path, map_location='cpu', weights_only=False)\n", + " model.load_state_dict(checkpoint[\"model\"], strict=False)\n", + "\n", + " return model, postprocessors, args\n", + "\n", + "######################################################\n", + "# 3) Simple transforms\n", + "######################################################\n", + "transform = T.Compose([\n", + " T.ToTensor(), # if your training used more elaborate transforms, replicate them\n", + "])\n", + "\n", + "######################################################\n", + "# 4) Inference + Box Conversion\n", + "######################################################\n", + "def run_inference(model, postprocessors, img_path, device, threshold=0.7, foreground_index=1):\n", + " \"\"\"\n", + " Inference with DETR for a single image.\n", + " :param threshold: probability threshold for detection.\n", + " :param foreground_index: which index in [num_classes+1] is our \"electron\" (vs background).\n", + " \"\"\"\n", + " img = Image.open(img_path).convert(\"RGB\")\n", + " w, h = img.size\n", + "\n", + " # Transform (to tensor)\n", + " img_tensor = transform(img).unsqueeze(0).to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model(img_tensor)\n", + " # \"pred_logits\": [1, 100, num_classes+1] => here: [1, 100, 2]\n", + " # \"pred_boxes\": [1, 100, 4] => [cx, cy, w, h] in [0..1]\n", + "\n", + " pred_logits = outputs[\"pred_logits\"][0] # shape [100, 2]\n", + " pred_boxes = outputs[\"pred_boxes\"][0] # shape [100, 4]\n", + "\n", + " # Softmax over the last dimension => probability for each of the 2 classes\n", + " probs = pred_logits.softmax(-1) # shape [100, 2]\n", + "\n", + " # We'll interpret index=foreground_index as \"electron\", index=0 as background\n", + " foreground_probs = probs[:, foreground_index] # e.g. probs[:, 1] if electron=1\n", + "\n", + " # Filter out low-confidence boxes\n", + " keep = foreground_probs > threshold\n", + " kept_boxes = pred_boxes[keep]\n", + " kept_scores = foreground_probs[keep]\n", + "\n", + " # Convert from [cx, cy, w, h] in [0..1] to [x_min, y_min, x_max, y_max] in pixel coords\n", + " boxes_xyxy = []\n", + " for b in kept_boxes:\n", + " cx, cy, bw, bh = b.tolist()\n", + " xmin = (cx - bw / 2) * w\n", + " xmax = (cx + bw / 2) * w\n", + " ymin = (cy - bh / 2) * h\n", + " ymax = (cy + bh / 2) * h\n", + " boxes_xyxy.append([xmin, ymin, xmax, ymax])\n", + "\n", + " # Debug prints: check the coords & scores\n", + " print(\"Detected boxes:\")\n", + " for (xmin, ymin, xmax, ymax), sc in zip(boxes_xyxy, kept_scores):\n", + " w_box = xmax - xmin\n", + " h_box = ymax - ymin\n", + " print(f\" [{xmin:.2f}, {ymin:.2f}, {xmax:.2f}, {ymax:.2f}] \"\n", + " f\"-> (w={w_box:.2f}, h={h_box:.2f}) score={sc:.3f}\")\n", + "\n", + " return img, boxes_xyxy, kept_scores.cpu().numpy()\n", + "\n", + "######################################################\n", + "# 5) Visualization\n", + "######################################################\n", + "def plot_boxes(img, boxes, scores):\n", + " plt.figure(figsize=(8, 8))\n", + " plt.imshow(img)\n", + " ax = plt.gca()\n", + "\n", + " for (xmin, ymin, xmax, ymax), sc in zip(boxes, scores):\n", + " # Just in case any box is out of bounds or negative\n", + " # clamp them here (optional):\n", + " xmin_plot = max(xmin, 0)\n", + " ymin_plot = max(ymin, 0)\n", + " xmax_plot = min(xmax, img.width)\n", + " ymax_plot = min(ymax, img.height)\n", + "\n", + " ax.add_patch(plt.Rectangle(\n", + " (xmin_plot, ymin_plot),\n", + " xmax_plot - xmin_plot,\n", + " ymax_plot - ymin_plot,\n", + " fill=False, \n", + " edgecolor='red', \n", + " linewidth=2\n", + " ))\n", + " ax.text(\n", + " xmin_plot, ymin_plot,\n", + " f\"{sc:.2f}\",\n", + " fontsize=8, \n", + " bbox=dict(facecolor='yellow', alpha=0.5)\n", + " )\n", + "\n", + " plt.title(\"DETR Inference Results\")\n", + " plt.show()\n", + "\n", + "######################################################\n", + "# 6) Main entry (test with a sample image)\n", + "######################################################\n", + "if __name__ == \"__main__\":\n", + " checkpoint_path = \"/home/da886/myDETR/detr/mytrainingoutputs/checkpoint0099.pth\"\n", + " test_image = \"/home/da886/myDETR/detr/train2017/000000000009.jpg\"\n", + "\n", + " device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + " # Build & load the model\n", + " model, postprocessors, args = get_inference_model(checkpoint_path)\n", + " model.to(device)\n", + "\n", + " # Run inference with threshold=0.7, class index=1\n", + " img, boxes, scores = run_inference(\n", + " model, postprocessors, \n", + " img_path=test_image, \n", + " device=device, \n", + " threshold=1, # or 0.5, etc.\n", + " foreground_index=91 # Assuming electron=1, background=0\n", + " )\n", + "\n", + " # Visualize\n", + " plot_boxes(img, boxes, scores)\n", + " print(\"Done!\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(640, 480)" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img.size" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[114.50551986694336,\n", + " 25.271422863006592,\n", + " 428.785457611084,\n", + " 235.63753366470337],\n", + " [304.83192443847656,\n", + " -0.22561311721801758,\n", + " 632.2756195068359,\n", + " 197.56202459335327],\n", + " [549.3295049667358, 205.3201138973236, 639.6561670303345, 304.73315834999084],\n", + " [318.7600517272949,\n", + " 0.8062148094177246,\n", + " 632.2490882873535,\n", + " 229.04922723770142],\n", + " [526.0649013519287, 202.9647660255432, 638.9420413970947, 328.19169759750366],\n", + " [280.98069190979004,\n", + " 274.12973642349243,\n", + " 448.1436824798584,\n", + " 445.67846059799194],\n", + " [417.44874000549316, 256.70978307724, 579.0972805023193, 435.194571018219],\n", + " [0.12712478637695312,\n", + " 197.98311710357666,\n", + " 612.704029083252,\n", + " 477.1923780441284],\n", + " [3.4726333618164062,\n", + " 192.70850658416748,\n", + " 629.1655349731445,\n", + " 475.9864282608032],\n", + " [55.510902404785156,\n", + " -0.2180778980255127,\n", + " 457.85892486572266,\n", + " 52.554835081100464],\n", + " [154.80950593948364,\n", + " 94.04927730560303,\n", + " 199.9813723564148,\n", + " 158.02255153656006],\n", + " [147.3030662536621,\n", + " 95.39866805076599,\n", + " 198.83794784545898,\n", + " 165.34486413002014],\n", + " [4.908795356750488, 130.71737408638, 144.8702573776245, 246.2136733531952],\n", + " [0.9307861328125, 168.4912919998169, 631.3507843017578, 477.6362371444702],\n", + " [7.15545654296875, 131.61529183387756, 108.38611602783203, 232.2608506679535],\n", + " [439.26865100860596,\n", + " 46.221925020217896,\n", + " 570.2644300460815,\n", + " 141.62299990653992],\n", + " [533.3264398574829,\n", + " -2.328118085861206,\n", + " 638.9709234237671,\n", + " 115.01294732093811],\n", + " [24.03970718383789, 329.9168300628662, 338.33940505981445, 478.9899158477783],\n", + " [-0.2780628204345703,\n", + " 39.870264530181885,\n", + " 285.43761253356934,\n", + " 204.46561574935913],\n", + " [450.17786979675293,\n", + " 283.52190613746643,\n", + " 554.5158863067627,\n", + " 393.65207076072693],\n", + " [502.4139451980591,\n", + " 395.89274883270264,\n", + " 639.6401929855347,\n", + " 479.48700428009033],\n", + " [457.38773822784424, 71.0806131362915, 556.6890287399292, 142.17873573303223],\n", + " [87.22176551818848, 242.56683111190796, 181.2463092803955, 292.8907799720764],\n", + " [258.88839960098267,\n", + " 190.00112771987915,\n", + " 307.2888159751892,\n", + " 227.93844938278198],\n", + " [182.47695684432983, 158.42868268489838, 237.546808719635, 200.919948220253],\n", + " [251.01699590682983,\n", + " 186.8499720096588,\n", + " 298.8123345375061,\n", + " 226.47437453269958],\n", + " [183.73116731643677,\n", + " 156.3425713777542,\n", + " 245.64051389694214,\n", + " 208.3976000547409],\n", + " [172.71520614624023,\n", + " 42.479363679885864,\n", + " 268.31464767456055,\n", + " 154.64603304862976],\n", + " [181.53005599975586, 35.14807462692261, 401.060848236084, 213.02440881729126],\n", + " [402.012083530426, 240.74288249015808, 457.8484511375427, 289.5002281665802],\n", + " [259.0886878967285, 188.99209856987, 314.426326751709, 228.36517453193665],\n", + " [1.292724609375, -0.7015299797058105, 640.3274536132812, 197.57142305374146],\n", + " [1.2487411499023438,\n", + " 37.844510078430176,\n", + " 446.51615142822266,\n", + " 391.4100122451782],\n", + " [72.55995750427246,\n", + " 337.75980949401855,\n", + " 347.25152015686035,\n", + " 476.8022060394287],\n", + " [201.14717960357666,\n", + " 31.491665840148926,\n", + " 343.850417137146,\n", + " 140.01500129699707],\n", + " [0.7946300506591797, 60.88356971740723, 238.1941318511963, 367.9910087585449],\n", + " [399.8309516906738, 47.89799451828003, 577.280330657959, 149.72453355789185],\n", + " [0.18662691116333008,\n", + " 395.57098031044006,\n", + " 54.46729898452759,\n", + " 480.2178990840912],\n", + " [459.30963039398193,\n", + " 65.72584390640259,\n", + " 568.4574747085571,\n", + " 144.87487077713013],\n", + " [80.14196395874023,\n", + " 236.48905634880066,\n", + " 200.57252883911133,\n", + " 296.84727787971497],\n", + " [272.8289532661438,\n", + " 194.49010580778122,\n", + " 313.14268827438354,\n", + " 223.5912922024727],\n", + " [344.74719047546387,\n", + " 0.3705132007598877,\n", + " 452.12925910949707,\n", + " 68.4567940235138],\n", + " [0.6288051605224609,\n", + " 107.44752645492554,\n", + " 236.27942085266113,\n", + " 288.6973214149475],\n", + " [329.990816116333, 0.06623268127441406, 625.4564189910889, 239.3010950088501],\n", + " [330.8626365661621,\n", + " 0.3094339370727539,\n", + " 617.3030281066895,\n", + " 170.58237075805664],\n", + " [0.6104707717895508,\n", + " 127.76920080184937,\n", + " 145.85534572601318,\n", + " 274.6234059333801],\n", + " [437.0438289642334, 380.03464221954346, 638.8702487945557, 479.405837059021],\n", + " [-1.1312055587768555,\n", + " 248.65949749946594,\n", + " 139.80542659759521,\n", + " 318.75528216362],\n", + " [145.4283094406128, 94.40053224563599, 195.2210283279419, 160.45055150985718],\n", + " [244.26875591278076, 26.5328711271286, 327.0146608352661, 67.58364021778107],\n", + " [170.76085090637207,\n", + " 34.41499471664429,\n", + " 375.38405418395996,\n", + " 205.28355360031128],\n", + " [334.9405860900879,\n", + " 0.17861366271972656,\n", + " 611.032772064209,\n", + " 148.91159534454346],\n", + " [396.6662406921387, 246.0045576095581, 569.4985389709473, 430.5158472061157],\n", + " [-0.034275054931640625,\n", + " 85.94452142715454,\n", + " 236.15493774414062,\n", + " 285.0333094596863],\n", + " [0.37178993225097656, 81.3632082939148, 258.2301998138428, 304.7355008125305],\n", + " [2.607278823852539,\n", + " 118.27400922775269,\n", + " 209.57852363586426,\n", + " 285.5904793739319],\n", + " [0.11819839477539062,\n", + " -0.05199909210205078,\n", + " 639.7283363342285,\n", + " 478.79297733306885],\n", + " [359.0254497528076,\n", + " 0.00026106834411621094,\n", + " 539.5370960235596,\n", + " 64.82586979866028],\n", + " [275.0548553466797, 224.3544316291809, 603.2722473144531, 461.5409731864929],\n", + " [157.41270065307617,\n", + " 90.32360672950745,\n", + " 217.0689582824707,\n", + " 178.68725180625916],\n", + " [513.5801076889038, 0.2593803405761719, 639.7198343276978, 73.51512908935547],\n", + " [369.1848850250244,\n", + " 0.5648481845855713,\n", + " 453.35585594177246,\n", + " 57.84109354019165],\n", + " [1.9300079345703125,\n", + " 43.7426233291626,\n", + " 457.76058197021484,\n", + " 457.49223232269287],\n", + " [408.5301399230957, 47.2518253326416, 502.4354362487793, 110.95245838165283],\n", + " [384.4052791595459,\n", + " 0.49271106719970703,\n", + " 638.5206699371338,\n", + " 477.5849676132202],\n", + " [186.64470434188843, 156.77590370178223, 235.12127161026, 194.97190475463867],\n", + " [0.11522293090820312,\n", + " -0.6775760650634766,\n", + " 636.3367652893066,\n", + " 287.8868579864502],\n", + " [205.73071479797363,\n", + " 39.091315269470215,\n", + " 382.5197505950928,\n", + " 218.00286769866943],\n", + " [513.8801145553589, 199.71354246139526, 639.3806886672974, 334.7319531440735],\n", + " [254.31909561157227, 221.7763638496399, 548.6451530456543, 454.6915125846863],\n", + " [308.8011360168457, 240.3346610069275, 587.4616813659668, 451.91444635391235],\n", + " [453.6975073814392, 47.63966202735901, 514.8590874671936, 86.07137560844421],\n", + " [429.0758991241455, 264.7901129722595, 560.3782176971436, 409.35306787490845],\n", + " [276.0424470901489, 283.022096157074, 356.4657163619995, 345.53863763809204],\n", + " [0.38504600524902344,\n", + " 74.80436325073242,\n", + " 211.02578163146973,\n", + " 273.4062194824219],\n", + " [2.9062271118164062,\n", + " 184.50307846069336,\n", + " 415.4496765136719,\n", + " 475.8556938171387],\n", + " [309.21234130859375,\n", + " 0.7468128204345703,\n", + " 631.5959930419922,\n", + " 244.31851387023926],\n", + " [-4.312610626220703, 185.03201007843018, 614.5471382141113, 468.19983959198],\n", + " [0.511016845703125,\n", + " 1.3409686088562012,\n", + " 327.7866744995117,\n", + " 148.86020421981812],\n", + " [23.79570960998535, 336.45535469055176, 342.1961498260498, 479.4315433502197],\n", + " [179.4657325744629,\n", + " 161.68846607208252,\n", + " 238.71870040893555,\n", + " 209.87927913665771],\n", + " [2.309255599975586,\n", + " 108.13162565231323,\n", + " 226.93041801452637,\n", + " 272.6191735267639],\n", + " [14.063520431518555, 81.75269365310669, 240.08404731750488, 271.753613948822],\n", + " [348.1825351715088,\n", + " 0.22523760795593262,\n", + " 459.57945823669434,\n", + " 74.1733467578888],\n", + " [524.807939529419, 200.03412008285522, 639.3966197967529, 351.6634011268616],\n", + " [1.1781024932861328,\n", + " 263.5255193710327,\n", + " 254.73332405090332,\n", + " 478.05059909820557],\n", + " [380.9183144569397, 36.07951462268829, 454.83478307724, 84.70082938671112],\n", + " [159.0185546875, 33.34489345550537, 386.90773010253906, 220.7836103439331],\n", + " [385.88401317596436,\n", + " 39.76812958717346,\n", + " 518.1800127029419,\n", + " 132.35121130943298],\n", + " [159.58489418029785,\n", + " 95.83803176879883,\n", + " 203.56818199157715,\n", + " 161.4869785308838],\n", + " [237.9640007019043, 43.77352952957153, 376.30884170532227, 194.345862865448],\n", + " [314.3858528137207, 258.2349228858948, 423.3325004577637, 335.8142066001892],\n", + " [525.559778213501, 202.47461915016174, 639.1477870941162, 304.52319502830505],\n", + " [0.9110450744628906,\n", + " -0.45359373092651367,\n", + " 236.22175216674805,\n", + " 79.54415559768677],\n", + " [477.14977264404297,\n", + " 1.8480420112609863,\n", + " 640.8872604370117,\n", + " 231.0455060005188],\n", + " [148.32577228546143,\n", + " 92.5814437866211,\n", + " 204.77450847625732,\n", + " 169.73444938659668],\n", + " [2.2936439514160156,\n", + " 213.0655288696289,\n", + " 629.3462562561035,\n", + " 476.75010681152344],\n", + " [317.00416564941406,\n", + " 1.2733840942382812,\n", + " 633.3149719238281,\n", + " 252.70686149597168],\n", + " [142.17041015625, 34.72909927368164, 405.00736236572266, 233.9176082611084],\n", + " [390.6018805503845, 238.8569676876068, 456.19735956192017, 295.9896433353424]]" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "boxes" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores.size" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "myfb", + "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.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/myDETR/code for cocoadaptation.ipynb b/myDETR/code for cocoadaptation.ipynb new file mode 100644 index 0000000..d660330 --- /dev/null +++ b/myDETR/code for cocoadaptation.ipynb @@ -0,0 +1,568 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "h5_filename = '/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10Fixed_200_256by256_95indexNoNoise_withBB.h5'#### i used this for validation\n", + "with h5py.File(h5_filename, 'r') as f:\n", + " images = np.array(f['images'])\n", + " centers = np.array(f['centers_training'])\n", + " boxes = np.array(f['bounding_boxes'])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10, 200, 4)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "boxes.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# import h5py\n", + "\n", + "# import numpy as np\n", + "\n", + "# from PIL import Image\n", + "\n", + "# import os\n", + "\n", + "\n", + "\n", + "# h5_path = \"/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10Fixed_200_256by256_95indexNoNoise_withBB.h5\"\n", + "\n", + "# output_images_dir = \"/home/da886/myDETR/mytrain\" # or val2017 if splitting\n", + "\n", + "# os.makedirs(output_images_dir, exist_ok=True)\n", + "\n", + "\n", + "\n", + "# with h5py.File(h5_path, \"r\") as f:\n", + "\n", + "# images = f[\"images\"] # shape (N, 256, 256)\n", + "\n", + "\n", + "\n", + "# for i in range(images.shape[0]):\n", + "\n", + "# # Convert single-channel array to PIL Image in \"L\" mode\n", + "\n", + "# img_array = images[i] # shape (256, 256)\n", + "\n", + "# img_pil = Image.fromarray(img_array.astype(np.uint8), mode=\"L\")\n", + "\n", + "\n", + "\n", + "# # Save as \"img0000.png\"\n", + "\n", + "# filename = f\"img{i:04d}.png\"\n", + "\n", + "# img_path = os.path.join(output_images_dir, filename)\n", + "\n", + "# img_pil.save(img_path)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# import h5py\n", + "# import os\n", + "# import json\n", + "\n", + "# # ---------------------------------------------------------------------\n", + "# # Paths\n", + "# # ---------------------------------------------------------------------\n", + "# # HDF5 file with bounding boxes\n", + "# H5_PATH = \"/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10Fixed_200_256by256_95indexNoNoise_withBB.h5\"\n", + "\n", + "# # The folder where you saved your PNG images (already extracted from the HDF5)\n", + "# TRAIN_IMAGES_DIR = \"/home/da886/myDETR/mytrain\"\n", + "\n", + "# # We will save the COCO annotation JSON here\n", + "# ANNOTATIONS_DIR = \"annotations\"\n", + "# os.makedirs(ANNOTATIONS_DIR, exist_ok=True)\n", + "\n", + "# ANNOTATIONS_FILE = os.path.join(ANNOTATIONS_DIR, \"instances_mytrain.json\")\n", + "\n", + "# # Single class name (for example)\n", + "# SINGLE_CLASS_NAME = \"electron\"\n", + "\n", + "# # ---------------------------------------------------------------------\n", + "# # 1) Open HDF5 and Read Boxes\n", + "# # ---------------------------------------------------------------------\n", + "# # We assume a dataset \"boxes\" of shape (N, M, 4): \n", + "# # N = # of images, M = # of boxes per image, 4 = [xmin, ymin, xmax, ymax].\n", + "# # If your shape or dataset name is different, modify accordingly.\n", + "\n", + "# with h5py.File(H5_PATH, \"r\") as f:\n", + "# # adjust the name of your bounding-box dataset if it's different than \"boxes\"\n", + "# boxes_dataset = f[\"bounding_boxes\"] # shape (N, M, 4)\n", + " \n", + "# # Double-check you have the same number of images as in 'mytrain2017' folder\n", + "# num_images = boxes_dataset.shape[0]\n", + "# print(f\"Found bounding boxes for {num_images} images in HDF5.\")\n", + "\n", + "# # ---------------------------------------------------------------------\n", + "# # 2) Build the COCO-style data structures\n", + "# # ---------------------------------------------------------------------\n", + "\n", + "# images = []\n", + "# annotations = []\n", + "# categories = [\n", + "# {\n", + "# \"id\": 1,\n", + "# \"name\": SINGLE_CLASS_NAME\n", + "# }\n", + "# ]\n", + "\n", + "# annotation_id = 1 # Each bounding box needs a unique annotation ID\n", + "\n", + "# # Get list of image files from your image folder, sorted by name\n", + "# image_files = sorted(os.listdir(TRAIN_IMAGES_DIR))\n", + "\n", + "# if len(image_files) != num_images:\n", + "# print(\"WARNING: The number of PNG files does not match the number of rows in 'boxes' dataset.\")\n", + "# print(f\" PNG files in {TRAIN_IMAGES_DIR}: {len(image_files)}\")\n", + "# print(f\" Rows in 'boxes': {num_images}\")\n", + "# print(\"Make sure these match or handle the difference carefully.\")\n", + " \n", + "# # Re-open the HDF5 for reading bounding boxes\n", + "# with h5py.File(H5_PATH, \"r\") as f:\n", + "# boxes_dataset = f[\"bounding_boxes\"] # shape (N, M, 4)\n", + "\n", + "# # Loop over each image index\n", + "# for i, img_file in enumerate(image_files):\n", + "# # Use 1-based indexing for COCO image ID\n", + "# image_id = i + 1\n", + "# # If you know the images are 256x256, that’s easy:\n", + "# width, height = 256, 256\n", + "\n", + "# # Add the \"images\" entry\n", + "# images.append({\n", + "# \"id\": image_id,\n", + "# \"file_name\": img_file,\n", + "# \"width\": width,\n", + "# \"height\": height\n", + "# })\n", + "\n", + "# # Get bounding boxes for this image: shape (M, 4) if M boxes\n", + "# # Adjust if your dataset is shaped differently\n", + "# boxes_for_image = boxes_dataset[i] # e.g. (M, 4)\n", + "\n", + "# # For each bounding box\n", + "# for box in boxes_for_image:\n", + "# xmin, ymin, xmax, ymax = box\n", + "\n", + "# # Convert [xmin, ymin, xmax, ymax] -> [x, y, w, h]\n", + "# x = float(xmin)\n", + "# y = float(ymin)\n", + "# w = float(xmax - xmin)\n", + "# h = float(ymax - ymin)\n", + "\n", + "# # Create an annotation entry\n", + "# ann_info = {\n", + "# \"id\": annotation_id,\n", + "# \"image_id\": image_id,\n", + "# \"category_id\": 1, # we have only one class\n", + "# \"bbox\": [x, y, w, h],\n", + "# \"area\": w * h,\n", + "# \"iscrowd\": 0\n", + "# }\n", + "# annotations.append(ann_info)\n", + "# annotation_id += 1\n", + "\n", + "# # ---------------------------------------------------------------------\n", + "# # 3) Save to COCO JSON\n", + "# # ---------------------------------------------------------------------\n", + "# coco_data = {\n", + "# \"images\": images,\n", + "# \"annotations\": annotations,\n", + "# \"categories\": categories\n", + "# }\n", + "\n", + "# os.makedirs(ANNOTATIONS_DIR, exist_ok=True)\n", + "\n", + "# with open(ANNOTATIONS_FILE, \"w\") as f:\n", + "# json.dump(coco_data, f, indent=2)\n", + "\n", + "# print(f\"\\nCOCO-style annotations saved to: {ANNOTATIONS_FILE}\")\n", + "# print(\"Done!\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading images from /home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10Fixed_200_256by256_95indexNoNoise_withBB.h5\n", + "Found 10 single-channel images. Converting to 3-channel RGB...\n", + "Done converting images to RGB!\n", + "Generating COCO annotations => annotations/instances_myval.json\n", + "COCO-style annotations saved to: annotations/instances_myval.json\n", + "All done!\n" + ] + } + ], + "source": [ + "# import h5py\n", + "# import numpy as np\n", + "# from PIL import Image\n", + "# import os\n", + "# import json\n", + "\n", + "# # ---------------------------------------------------------------------\n", + "# # 0) Configuration\n", + "# # ---------------------------------------------------------------------\n", + "# # Path to HDF5 with single-channel images & bounding boxes\n", + "# # H5_PATH = \"/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/1000Fixed_200_256by256_95indexNoNoise_withBB.h5\" ##### i used this for training\n", + "# H5_PATH = \"/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/10Fixed_200_256by256_95indexNoNoise_withBB.h5\"\n", + "\n", + "# # Where to save the extracted (converted to RGB) images\n", + "# OUTPUT_IMAGES_DIR = \"/home/da886/myDETR/myval\" # or \"myVAL\" if splitting\n", + "\n", + "# # COCO annotation folder / file\n", + "# ANNOTATIONS_DIR = \"annotations\"\n", + "# ANNOTATIONS_FILE = \"instances_myval.json\"\n", + "\n", + "# # Single class name\n", + "# SINGLE_CLASS_NAME = \"electron\"\n", + "\n", + "# # Image dimensions (known from your dataset)\n", + "# WIDTH, HEIGHT = 256, 256\n", + "\n", + "# def main():\n", + "# # ---------------------------------------------------------------------\n", + "# # 1) Extract single-channel images, replicate to RGB, save as PNG\n", + "# # ---------------------------------------------------------------------\n", + "# os.makedirs(OUTPUT_IMAGES_DIR, exist_ok=True)\n", + "\n", + "# print(f\"Reading images from {H5_PATH}\")\n", + "# with h5py.File(H5_PATH, \"r\") as f:\n", + "# images_dataset = f[\"images\"] # shape (N, 256, 256)\n", + "# num_images = images_dataset.shape[0]\n", + "# print(f\"Found {num_images} single-channel images. Converting to 3-channel RGB...\")\n", + "\n", + "# for i in range(num_images):\n", + "# # shape (256, 256) single-channel\n", + "# img_array = images_dataset[i]\n", + "\n", + "# # Replicate channel: shape (256, 256, 3)\n", + "# img_array_3ch = np.stack([img_array, img_array, img_array], axis=-1)\n", + "\n", + "# # Convert to PIL image in \"RGB\"\n", + "# img_pil = Image.fromarray(img_array_3ch.astype(np.uint8), mode=\"RGB\")\n", + "\n", + "# # Save as \"img0000.png\"\n", + "# filename = f\"img{i:04d}.png\"\n", + "# img_path = os.path.join(OUTPUT_IMAGES_DIR, filename)\n", + "# img_pil.save(img_path)\n", + "\n", + "# print(\"Done converting images to RGB!\")\n", + "\n", + "# # ---------------------------------------------------------------------\n", + "# # 2) Build COCO-style annotations\n", + "# # ---------------------------------------------------------------------\n", + "# # Create an 'annotations' folder for the JSON\n", + "# os.makedirs(ANNOTATIONS_DIR, exist_ok=True)\n", + "# out_json = os.path.join(ANNOTATIONS_DIR, ANNOTATIONS_FILE)\n", + "\n", + "# print(f\"Generating COCO annotations => {out_json}\")\n", + "\n", + "# # We'll read bounding boxes again from the HDF5 file\n", + "# with h5py.File(H5_PATH, \"r\") as f:\n", + "# boxes_dataset = f[\"bounding_boxes\"] # shape (N, M, 4)\n", + "# num_images_bbox = boxes_dataset.shape[0]\n", + "\n", + "# # Basic sanity check\n", + "# image_files = sorted(os.listdir(OUTPUT_IMAGES_DIR))\n", + "# if len(image_files) != num_images_bbox:\n", + "# print(\"WARNING: Mismatch in image count vs bounding box count!\")\n", + "# print(f\" PNG files in {OUTPUT_IMAGES_DIR}: {len(image_files)}\")\n", + "# print(f\" Rows in 'bounding_boxes': {num_images_bbox}\")\n", + "\n", + "# # COCO data placeholders\n", + "# images = []\n", + "# annotations = []\n", + "# categories = [\n", + "# {\n", + "# \"id\": 1,\n", + "# \"name\": SINGLE_CLASS_NAME\n", + "# }\n", + "# ]\n", + "# annotation_id = 1\n", + "\n", + "# # Reopen to read bounding boxes\n", + "# with h5py.File(H5_PATH, \"r\") as f:\n", + "# boxes_dataset = f[\"bounding_boxes\"] # shape (N, M, 4)\n", + "# for i, img_file in enumerate(image_files):\n", + "# image_id = i + 1\n", + "# images.append({\n", + "# \"id\": image_id,\n", + "# \"file_name\": img_file,\n", + "# \"width\": WIDTH,\n", + "# \"height\": HEIGHT\n", + "# })\n", + "\n", + "# # For each image i, get all boxes\n", + "# boxes_for_image = boxes_dataset[i] # shape (M, 4)\n", + "# for box in boxes_for_image:\n", + "# xmin, ymin, xmax, ymax = box\n", + "\n", + "# # Convert [xmin, ymin, xmax, ymax] -> [x, y, w, h]\n", + "# x = float(xmin)\n", + "# y = float(ymin)\n", + "# w = float(xmax - xmin)\n", + "# h = float(ymax - ymin)\n", + "\n", + "# ann_info = {\n", + "# \"id\": annotation_id,\n", + "# \"image_id\": image_id,\n", + "# \"category_id\": 1, # single class\n", + "# \"bbox\": [x, y, w, h],\n", + "# \"area\": w * h,\n", + "# \"iscrowd\": 0\n", + "# }\n", + "# annotations.append(ann_info)\n", + "# annotation_id += 1\n", + "\n", + "# # Combine into final COCO dict\n", + "# coco_data = {\n", + "# \"images\": images,\n", + "# \"annotations\": annotations,\n", + "# \"categories\": categories\n", + "# }\n", + "\n", + "# # Write JSON\n", + "# with open(out_json, \"w\") as f:\n", + "# json.dump(coco_data, f, indent=2)\n", + "\n", + "# print(f\"COCO-style annotations saved to: {out_json}\")\n", + "# print(\"All done!\")\n", + "\n", + "# if __name__ == \"__main__\":\n", + "# main()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading images from /home/da886/Final Electron counting project/Images and Labels/Images For Tiles/100Fixed_20_256by256_95indexNoNoise_withBB.h5\n", + "Found 1000 single-channel images. Converting to 3-channel RGB...\n", + "Done converting images to RGB!\n", + "Generating COCO annotations => annotations/instances_val2017.json\n", + "COCO-style annotations saved to: annotations/instances_val2017.json\n", + "All done!\n" + ] + } + ], + "source": [ + "import h5py\n", + "import numpy as np\n", + "from PIL import Image\n", + "import os\n", + "import json\n", + "import random # for assigning random category IDs\n", + "\n", + "# ---------------------------------------------------------------------\n", + "# 0) Configuration\n", + "# ---------------------------------------------------------------------\n", + "H5_PATH = \"/home/da886/Final Electron counting project/Images and Labels/Images For Tiles/100Fixed_20_256by256_95indexNoNoise_withBB.h5\"\n", + "OUTPUT_IMAGES_DIR = \"/home/da886/myDETR/myval\" # or \"myVAL\" if splitting\n", + "\n", + "ANNOTATIONS_DIR = \"annotations\"\n", + "ANNOTATIONS_FILE = \"instances_val2017.json\"\n", + "\n", + "SINGLE_CLASS_NAME = \"electron\"\n", + "WIDTH, HEIGHT = 256, 256\n", + "\n", + "# How many total classes in your dataset\n", + "NUM_CLASSES = 20\n", + "\n", + "def main():\n", + " # ---------------------------------------------------------------------\n", + " # 1) Extract single-channel images, replicate to RGB, save as PNG\n", + " # ---------------------------------------------------------------------\n", + " os.makedirs(OUTPUT_IMAGES_DIR, exist_ok=True)\n", + "\n", + " print(f\"Reading images from {H5_PATH}\")\n", + " with h5py.File(H5_PATH, \"r\") as f:\n", + " images_dataset = f[\"images\"] # shape (N, 256, 256)\n", + " num_images = images_dataset.shape[0]\n", + " print(f\"Found {num_images} single-channel images. Converting to 3-channel RGB...\")\n", + "\n", + " for i in range(num_images):\n", + " # shape (256, 256) single-channel\n", + " img_array = images_dataset[i]\n", + "\n", + " # Replicate channel: shape (256, 256, 3)\n", + " img_array_3ch = np.stack([img_array, img_array, img_array], axis=-1)\n", + "\n", + " # Convert to PIL image in \"RGB\"\n", + " img_pil = Image.fromarray(img_array_3ch.astype(np.uint8), mode=\"RGB\")\n", + "\n", + " # Save as \"img0000.png\"\n", + " filename = f\"img{i:04d}.png\"\n", + " img_path = os.path.join(OUTPUT_IMAGES_DIR, filename)\n", + " img_pil.save(img_path)\n", + "\n", + " print(\"Done converting images to RGB!\")\n", + "\n", + " # ---------------------------------------------------------------------\n", + " # 2) Build COCO-style annotations\n", + " # ---------------------------------------------------------------------\n", + " # Create an 'annotations' folder for the JSON\n", + " os.makedirs(ANNOTATIONS_DIR, exist_ok=True)\n", + " out_json = os.path.join(ANNOTATIONS_DIR, ANNOTATIONS_FILE)\n", + "\n", + " print(f\"Generating COCO annotations => {out_json}\")\n", + "\n", + " # We'll read bounding boxes again from the HDF5 file\n", + " with h5py.File(H5_PATH, \"r\") as f:\n", + " boxes_dataset = f[\"bounding_boxes\"] # shape (N, M, 4)\n", + " num_images_bbox = boxes_dataset.shape[0]\n", + "\n", + " # Basic sanity check\n", + " image_files = sorted(os.listdir(OUTPUT_IMAGES_DIR))\n", + " if len(image_files) != num_images_bbox:\n", + " print(\"WARNING: Mismatch in image count vs bounding box count!\")\n", + " print(f\" PNG files in {OUTPUT_IMAGES_DIR}: {len(image_files)}\")\n", + " print(f\" Rows in 'bounding_boxes': {num_images_bbox}\")\n", + "\n", + " # COCO data placeholders\n", + " images = []\n", + " annotations = []\n", + "\n", + " # Pre-build the 20 categories (IDs 1..20)\n", + " categories = [\n", + " {\n", + " \"id\": c,\n", + " \"name\": f\"{SINGLE_CLASS_NAME}_{c}\"\n", + " }\n", + " for c in range(1, NUM_CLASSES + 1)\n", + " ]\n", + "\n", + " annotation_id = 1\n", + "\n", + " # Reopen to read bounding boxes\n", + " with h5py.File(H5_PATH, \"r\") as f:\n", + " boxes_dataset = f[\"bounding_boxes\"] # shape (N, M, 4)\n", + " for i, img_file in enumerate(image_files):\n", + " image_id = i + 1\n", + "\n", + " images.append({\n", + " \"id\": image_id,\n", + " \"file_name\": img_file,\n", + " \"width\": WIDTH,\n", + " \"height\": HEIGHT\n", + " })\n", + "\n", + " # For each bounding box in this image\n", + " boxes_for_image = boxes_dataset[i] # shape (M, 4)\n", + " for box in boxes_for_image:\n", + " xmin, ymin, xmax, ymax = box\n", + "\n", + " # Convert [xmin, ymin, xmax, ymax] -> [x, y, w, h]\n", + " x = float(xmin)\n", + " y = float(ymin)\n", + " w = float(xmax - xmin)\n", + " h = float(ymax - ymin)\n", + "\n", + " # --- Pick a random category ID between 1 and NUM_CLASSES ---\n", + " random_class_id = random.randint(1, NUM_CLASSES)\n", + "\n", + " ann_info = {\n", + " \"id\": annotation_id,\n", + " \"image_id\": image_id,\n", + " \"category_id\": random_class_id,\n", + " \"bbox\": [x, y, w, h],\n", + " \"area\": w * h,\n", + " \"iscrowd\": 0\n", + " }\n", + " annotations.append(ann_info)\n", + " annotation_id += 1\n", + "\n", + " # Combine into final COCO dict\n", + " coco_data = {\n", + " \"images\": images,\n", + " \"annotations\": annotations,\n", + " \"categories\": categories\n", + " }\n", + "\n", + " # Write JSON\n", + " with open(out_json, \"w\") as f:\n", + " json.dump(coco_data, f, indent=2)\n", + "\n", + " print(f\"COCO-style annotations saved to: {out_json}\")\n", + " print(\"All done!\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " main()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sod", + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/myDETR/detr b/myDETR/detr new file mode 160000 index 0000000..29901c5 --- /dev/null +++ b/myDETR/detr @@ -0,0 +1 @@ +Subproject commit 29901c51d7fe8712168b8d0d64351170bc0f83e0 diff --git a/mymodifiedresne34.keras b/mymodifiedresne34.keras deleted file mode 100644 index 93635e3..0000000 Binary files a/mymodifiedresne34.keras and /dev/null differ diff --git a/yolov5 b/yolov5 new file mode 160000 index 0000000..24ee280 --- /dev/null +++ b/yolov5 @@ -0,0 +1 @@ +Subproject commit 24ee28010fbf597ec796e6e471429cde21040f90