From ac06c6e1b2afaeb6055bd79d74d0f0e22071c38e Mon Sep 17 00:00:00 2001 From: DHRUV BANSAL Date: Thu, 6 May 2021 12:00:44 +0530 Subject: [PATCH] Add files via upload --- Autoencoder.ipynb | 758 +++++++++++++++++++++++++++++++--------------- 1 file changed, 519 insertions(+), 239 deletions(-) diff --git a/Autoencoder.ipynb b/Autoencoder.ipynb index 6ba48bd..63b1f12 100644 --- a/Autoencoder.ipynb +++ b/Autoencoder.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "id": "handled-prayer", "metadata": {}, "source": [ "
\n", @@ -18,226 +17,249 @@ { "cell_type": "code", "execution_count": 1, - "id": "optional-portland", "metadata": {}, "outputs": [], "source": [ - "import keras\n", - "from keras import layers\n", - "import matplotlib.pyplot as plt\n", - "from tensorflow.keras.preprocessing.image import load_img\n", - "from tensorflow.keras.preprocessing.image import img_to_array\n", - "from sklearn.preprocessing import LabelBinarizer\n", - "from sklearn.model_selection import train_test_split\n", - "from keras.layers import Input\n", - "from keras.utils.vis_utils import plot_model\n", - "import pandas as pd\n", - "import numpy as np\n", - "import json\n", - "import os\n", - "from imutils import paths\n", - "import cv2" + "# import sys\n", + "# !{sys.executable} -m pip install keras\n", + "# !{sys.executable} -m pip install matplotlib\n", + "# !{sys.executable} -m pip install pandas\n", + "# !{sys.executable} -m pip install imutils\n", + "# !{sys.executable} -m pip install opencv-python\n", + "# !{sys.executable} -m pip install sklearn\n", + "# !{sys.executable} -m pip install --upgrade pip\n", + "# !{sys.executable} -m pip install -q tfds-nightly tensorflow\n", + "# !{sys.executable} -m pip install pydot\n", + "# !{sys.executable} -m pip install graphviz\n", + "# !{sys.executable} -m pip install pydotplus" ] }, { "cell_type": "code", "execution_count": 2, - "id": "legitimate-neutral", "metadata": {}, "outputs": [], "source": [ - "Base_Path = \"/media/beast/Samsung_T5/nVidia_Research_Work\"" - ] - }, - { - "cell_type": "markdown", - "id": "severe-portrait", - "metadata": {}, - "source": [ - "## DATA IN FORMAT\n", - " Base_Path
\n", - "  |-train2017
\n", - "  |-val2017
\n", - "  |-annotations_val(without_column_names).csv
\n", - "  |-annotations_train(without_column_names).csv
" - ] - }, - { - "cell_type": "markdown", - "id": "compressed-income", - "metadata": {}, - "source": [ - "for csv files first run \"Preparing_Dataset.ipynb\"" + "import keras\n", + "from tensorflow.keras import layers\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "from tensorflow.keras.preprocessing.image import load_img \n", + "from tensorflow.keras.preprocessing.image import img_to_array\n", + "from keras.layers import Input\n", + "from keras.preprocessing import image\n", + "from keras import backend as K\n", + "from tensorflow.python.keras.utils.vis_utils import plot_model\n", + "import tensorflow_addons as tfa\n", + "import tensorflow_datasets as tfds\n", + "import numpy as np\n", + "import json\n", + "from functools import partial\n", + "import os\n", + "from imutils import paths\n", + "import cv2\n", + "import IPython.display as display\n", + "import multiprocessing" ] }, { "cell_type": "code", "execution_count": 3, - "id": "lasting-doctrine", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3.1\n" + ] + } + ], "source": [ - "Train_Images_Path = os.path.sep.join([Base_Path, 'train2017'])\n", - "Val_Images_Path = os.path.sep.join([Base_Path, 'val2017'])\n", - "Annots_Val_Path = os.path.sep.join([Base_Path, 'annotations_val(without_column_names).csv'])\n", - "Annots_Train_Path = os.path.sep.join([Base_Path, 'annotations_train(without_column_names).csv'])\n", - "# Lb_Path = os.path.sep.join([Base_Path, 'lb.pickle'])" + "print(tf.__version__)" ] }, { - "cell_type": "markdown", - "id": "developmental-pendant", + "cell_type": "code", + "execution_count": 4, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found GPU at: {} /device:GPU:0\n" + ] + } + ], "source": [ - "## Setting Up training data" + "device_name = tf.test.gpu_device_name()\n", + "if device_name != '/device:GPU:0':\n", + " raise SystemError('GPU device not found')\n", + "print('Found GPU at: {}',format(device_name))" ] }, { "cell_type": "code", - "execution_count": null, - "id": "interracial-venue", + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "print(\"[INFO] loading dataset....\")\n", - "data_train = []\n", - "# labels_train = []\n", - "# bboxes_train = []\n", - "# image_Paths_train = []\n", - "rows = open(Annots_Train_Path).read().strip().split(\"\\n\")\n", - "for row in rows:\n", - " row = row.split(\",\")\n", - " (filename, startX, startY, endX, endY, cat_ID, cat_Name) = row\n", - " imagePath = os.path.sep.join([Train_Images_Path, filename])\n", - " image = cv2.imread(imagePath)\n", - " (h, w) = image.shape[:2]\n", - " startX = float(startX) / w\n", - " startY = float(startY) / h\n", - " endX = float(endX) / w\n", - " endY = float(endY) / h\n", - " image = load_img(imagePath, target_size = (512,512))\n", - " image = img_to_array(image)\n", - " data_train.append(image)\n", - "# labels_train.append(cat_Name)\n", - "# bboxes_train.append((startX, startY, endX, endY))\n", - "# image_Paths_train.append(imagePath)\n", - " print(len(data_train))" + "AUTOTUNE = tf.data.experimental.AUTOTUNE\n", + "IMAGE_SIZE = [512,512]\n", + "BATCH_SIZE = 4" ] }, { - "cell_type": "markdown", - "id": "reduced-delicious", + "cell_type": "code", + "execution_count": 6, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Tfrecords Files: 256\n", + "Test Tfrecords Files: 64\n", + "Valid Tfrecords Files: 8\n" + ] + } + ], "source": [ - "## Setting up validation data" + "file_pattern_train = f'coco/2017/1.1.0/coco-train.tfrecord*'\n", + "file_pattern_test = f'coco/2017/1.1.0/coco-test.tfrecord*'\n", + "file_pattern_valid = f'coco/2017/1.1.0/coco-validation.tfrecord*'\n", + "Training_filenames = tf.data.Dataset.list_files(file_pattern_train)\n", + "Test_filenames = tf.data.Dataset.list_files(file_pattern_test)\n", + "Valid_filenames = tf.data.Dataset.list_files(file_pattern_valid)\n", + "print(\"Train Tfrecords Files: \", len(Training_filenames))\n", + "print(\"Test Tfrecords Files: \", len(Test_filenames))\n", + "print(\"Valid Tfrecords Files: \", len(Valid_filenames))" ] }, { "cell_type": "code", - "execution_count": null, - "id": "virtual-morocco", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "print(\"[INFO] loading dataset....\")\n", - "data_val = []\n", - "# labels_train = []\n", - "# bboxes_train = []\n", - "# image_Paths_train = []\n", - "rows = open(Annots_Val_Path).read().strip().split(\"\\n\")\n", - "for row in rows:\n", - " row = row.split(\",\")\n", - " (filename, startX, startY, endX, endY, cat_ID, cat_Name) = row\n", - " imagePath = os.path.sep.join([Val_Images_Path, filename])\n", - " image = cv2.imread(imagePath)\n", - " (h, w) = image.shape[:2]\n", - " startX = float(startX) / w\n", - " startY = float(startY) / h\n", - " endX = float(endX) / w\n", - " endY = float(endY) / h\n", - " image = load_img(imagePath, target_size = (512,512))\n", - " image = img_to_array(image)\n", - " data_val.append(image)\n", - "# labels_train.append(cat_Name)\n", - "# bboxes_train.append((startX, startY, endX, endY))\n", - "# image_Paths_train.append(imagePath)\n", - " print(len(data_val))" - ] - }, - { - "cell_type": "markdown", - "id": "veterinary-burning", - "metadata": {}, - "source": [ - "## Saving variables to prevent loading data again and again" + "def decode_image(image):\n", + " image = tf.io.decode_jpeg(image, channels=3)\n", + " image = tf.cast(image, tf.float32)\n", + " image = tf.image.resize(image, [*IMAGE_SIZE])\n", + " paddings = tf.constant([[1,1], [1,1], [0,0]])\n", + " image = tf.pad(image, paddings, \"CONSTANT\")\n", + " image = tf.image.resize(image, [*IMAGE_SIZE])\n", + " return image" ] }, { "cell_type": "code", - "execution_count": null, - "id": "referenced-kernel", + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "# import dill\n", - "# dill.dump_session('autoencoder_variables.db')\n", - "# dill.load_session('autoencoder_variables.db')" - ] - }, - { - "cell_type": "markdown", - "id": "solid-license", - "metadata": {}, - "source": [ - "converting images into numpy array" + "def read_tfrecord(serialized_example):\n", + " feature_description={\n", + " \"image\": tf.io.FixedLenFeature([], tf.string,)\n", + " }\n", + " example = tf.io.parse_single_example(\n", + " serialized_example, feature_description\n", + " )\n", + " image = decode_image(example['image'])\n", + " return image" ] }, { "cell_type": "code", - "execution_count": null, - "id": "virtual-suite", + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "data = np.array(data_train, dtype=\"float32\") / 255.0\n", - "(val_images) = np.array(data_val, dtype=\"float32\") / 255.0\n", - "# labels = np.array(labels)\n", - "# bboxes = np.array(bboxes, dtype = \"float32\")\n", - "# image_Paths = np.array(image_Paths)" + "def load_dataset(filenames):\n", + " ignore_order = tf.data.Options()\n", + " ignore_order.experimental_deterministic = False\n", + " dataset = tf.data.TFRecordDataset(\n", + " filenames)\n", + " dataset = dataset.with_options(ignore_order)\n", + " dataset =dataset.map(\n", + " partial(read_tfrecord), num_parallel_calls=AUTOTUNE)\n", + " return dataset" ] }, { "cell_type": "code", - "execution_count": null, - "id": "utility-routine", + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "# lb = LabelBinarizer()\n", - "# labels = lb.fit_transform(labels)" + "def get_dataset(filenames):\n", + " dataset = load_dataset(filenames)\n", + " dataset = dataset.shuffle(1024)\n", + " dataset = dataset.prefetch(buffer_size=AUTOTUNE)\n", + " dataset = dataset.batch(BATCH_SIZE)\n", + " return dataset" ] }, { - "cell_type": "markdown", - "id": "meaningful-pillow", + "cell_type": "code", + "execution_count": 11, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(512, 512, 3)\n", + "(512, 512, 3)\n", + "(512, 512, 3)\n", + "(512, 512, 3)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "## splitting dataset" + "train_dataset = get_dataset(Training_filenames)\n", + "valid_dataset = get_dataset(Valid_filenames)\n", + "test_dataset = get_dataset(Test_filenames)\n", + "# train_dist_datset = strategy.experimental_distribute_dataset(train_dataset)\n", + "# test_dist_dataset = strategy.experimental_distribute_dataset(test_dataset)\n", + "# valid_dist_dataset = strategy.experimental_distribute_dataset(valid_dataset)\n", + "image_batch = next(iter(train_dataset))\n", + "def show_batch_original(image_batch):\n", + " plt.figure(figsize=(10,10))\n", + " for n in range(4):\n", + " ax = plt.subplot(5,5, n+1)\n", + " print(image_batch[n].shape)\n", + " plt.imshow(image_batch[n] / 255.0)\n", + " plt.axis(\"off\")\n", + " \n", + "show_batch_original(image_batch.numpy())" ] }, { "cell_type": "code", - "execution_count": null, - "id": "figured-estate", + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "(train_images, test_images) = train_test_split(data, test_size=0.10, random_state = 42)" + "checkpoint_dir = './training_checkpoints'\n", + "checkpoint_prefix = os.path.join(checkpoint_dir, 'ckpt')" ] }, { "cell_type": "markdown", - "id": "outdoor-duration", "metadata": {}, "source": [ "## Preparing autoencoder" @@ -245,84 +267,180 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "junior-company", + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "input_img = Input(shape=(512,512,3))\n", - "x = layers.Conv2D(256, (3,3), activation='relu', padding='same')(input_img)\n", + "x = layers.Conv2D(256, (1,1), activation='relu', padding='same')(input_img)\n", "x = layers.MaxPooling2D((2,2), padding = 'same')(x)\n", "x = layers.Conv2D(128, (3,3), activation='relu', padding='same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.MaxPooling2D((2,2), padding = 'same')(x)\n", "x = layers.Conv2D(64, (3,3), activation='relu', padding='same')(x)\n", + "x = layers.BatchNormalization()(x)\n", + "x = layers.MaxPooling2D((2,2), padding = 'same')(x)\n", + "x = layers.Conv2D(64, (3,3), activation='relu', padding='same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.MaxPooling2D((2,2), padding = 'same')(x)\n", "x = layers.Conv2D(32, (3,3), activation='relu', padding='same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.MaxPooling2D((2,2), padding = 'same')(x)\n", "x = layers.Conv2D(16, (3,3), activation='relu', padding='same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.MaxPooling2D((2,2), padding='same')(x)\n", "x = layers.Conv2D(16, (3,3), activation='relu', padding='same')(x)\n", - "x = layers.MaxPooling2D((2,2), padding='same')(x)\n", - "x = layers.Conv2D(8, (3,3), activation='relu', padding='same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "encoded = layers.MaxPooling2D((2,2), padding='same')(x)\n", - "\n", - "##################################################################\n", - "\n", - "x = layers.Conv2D(8, (3,3), activation='relu', padding='same')(encoded)\n", - "x = layers.UpSampling2D((2,2))(x)\n", - "x = layers.Conv2D(16, (3,3), activation='relu', padding = 'same')(x)\n", + "x = layers.Conv2D(16, (3,3), activation='relu', padding='same')(encoded)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.UpSampling2D((2,2))(x)\n", "x = layers.Conv2D(16, (3,3), activation = 'relu', padding = 'same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.UpSampling2D((2,2))(x)\n", "x = layers.Conv2D(32, (3,3), activation = 'relu', padding= 'same')(x)\n", + "x = layers.BatchNormalization()(x)\n", + "x = layers.UpSampling2D((2,2))(x)\n", + "x = layers.Conv2D(64, (3,3), activation = 'relu', padding= 'same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.UpSampling2D((2,2))(x)\n", "x = layers.Conv2D(64, (3,3), activation = 'relu', padding= 'same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.UpSampling2D((2,2))(x)\n", "x = layers.Conv2D(128, (3,3), activation = 'relu', padding= 'same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.UpSampling2D((2,2))(x)\n", "x = layers.Conv2D(256, (3,3), activation = 'relu', padding= 'same')(x)\n", + "x = layers.BatchNormalization()(x)\n", "x = layers.UpSampling2D((2,2))(x)\n", "decoded = layers.Conv2D(3, (3,3), activation='sigmoid', padding='same')(x)\n", "\n", - "autoencoder = keras.Model(input_img, decoded)\n", - "autoencoder.compile(optimizer='adam', loss='binary_crossentropy', metrics=[\"accuracy\"])" + "\n", + "autoencoder = tf.keras.Model(inputs=input_img, outputs=decoded)\n" ] }, { "cell_type": "code", - "execution_count": null, - "id": "deluxe-thesis", + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"functional_1\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_1 (InputLayer) [(None, 512, 512, 3)] 0 \n", + "_________________________________________________________________\n", + "conv2d (Conv2D) (None, 512, 512, 256) 1024 \n", + "_________________________________________________________________\n", + "max_pooling2d (MaxPooling2D) (None, 256, 256, 256) 0 \n", + "_________________________________________________________________\n", + "conv2d_1 (Conv2D) (None, 256, 256, 128) 295040 \n", + "_________________________________________________________________\n", + "batch_normalization (BatchNo (None, 256, 256, 128) 512 \n", + "_________________________________________________________________\n", + "max_pooling2d_1 (MaxPooling2 (None, 128, 128, 128) 0 \n", + "_________________________________________________________________\n", + "conv2d_2 (Conv2D) (None, 128, 128, 64) 73792 \n", + "_________________________________________________________________\n", + "batch_normalization_1 (Batch (None, 128, 128, 64) 256 \n", + "_________________________________________________________________\n", + "max_pooling2d_2 (MaxPooling2 (None, 64, 64, 64) 0 \n", + "_________________________________________________________________\n", + "conv2d_3 (Conv2D) (None, 64, 64, 64) 36928 \n", + "_________________________________________________________________\n", + "batch_normalization_2 (Batch (None, 64, 64, 64) 256 \n", + "_________________________________________________________________\n", + "max_pooling2d_3 (MaxPooling2 (None, 32, 32, 64) 0 \n", + "_________________________________________________________________\n", + "conv2d_4 (Conv2D) (None, 32, 32, 32) 18464 \n", + "_________________________________________________________________\n", + "batch_normalization_3 (Batch (None, 32, 32, 32) 128 \n", + "_________________________________________________________________\n", + "max_pooling2d_4 (MaxPooling2 (None, 16, 16, 32) 0 \n", + "_________________________________________________________________\n", + "conv2d_5 (Conv2D) (None, 16, 16, 16) 4624 \n", + "_________________________________________________________________\n", + "batch_normalization_4 (Batch (None, 16, 16, 16) 64 \n", + "_________________________________________________________________\n", + "max_pooling2d_5 (MaxPooling2 (None, 8, 8, 16) 0 \n", + "_________________________________________________________________\n", + "conv2d_6 (Conv2D) (None, 8, 8, 16) 2320 \n", + "_________________________________________________________________\n", + "batch_normalization_5 (Batch (None, 8, 8, 16) 64 \n", + "_________________________________________________________________\n", + "max_pooling2d_6 (MaxPooling2 (None, 4, 4, 16) 0 \n", + "_________________________________________________________________\n", + "conv2d_7 (Conv2D) (None, 4, 4, 16) 2320 \n", + "_________________________________________________________________\n", + "batch_normalization_6 (Batch (None, 4, 4, 16) 64 \n", + "_________________________________________________________________\n", + "up_sampling2d (UpSampling2D) (None, 8, 8, 16) 0 \n", + "_________________________________________________________________\n", + "conv2d_8 (Conv2D) (None, 8, 8, 16) 2320 \n", + "_________________________________________________________________\n", + "batch_normalization_7 (Batch (None, 8, 8, 16) 64 \n", + "_________________________________________________________________\n", + "up_sampling2d_1 (UpSampling2 (None, 16, 16, 16) 0 \n", + "_________________________________________________________________\n", + "conv2d_9 (Conv2D) (None, 16, 16, 32) 4640 \n", + "_________________________________________________________________\n", + "batch_normalization_8 (Batch (None, 16, 16, 32) 128 \n", + "_________________________________________________________________\n", + "up_sampling2d_2 (UpSampling2 (None, 32, 32, 32) 0 \n", + "_________________________________________________________________\n", + "conv2d_10 (Conv2D) (None, 32, 32, 64) 18496 \n", + "_________________________________________________________________\n", + "batch_normalization_9 (Batch (None, 32, 32, 64) 256 \n", + "_________________________________________________________________\n", + "up_sampling2d_3 (UpSampling2 (None, 64, 64, 64) 0 \n", + "_________________________________________________________________\n", + "conv2d_11 (Conv2D) (None, 64, 64, 64) 36928 \n", + "_________________________________________________________________\n", + "batch_normalization_10 (Batc (None, 64, 64, 64) 256 \n", + "_________________________________________________________________\n", + "up_sampling2d_4 (UpSampling2 (None, 128, 128, 64) 0 \n", + "_________________________________________________________________\n", + "conv2d_12 (Conv2D) (None, 128, 128, 128) 73856 \n", + "_________________________________________________________________\n", + "batch_normalization_11 (Batc (None, 128, 128, 128) 512 \n", + "_________________________________________________________________\n", + "up_sampling2d_5 (UpSampling2 (None, 256, 256, 128) 0 \n", + "_________________________________________________________________\n", + "conv2d_13 (Conv2D) (None, 256, 256, 256) 295168 \n", + "_________________________________________________________________\n", + "batch_normalization_12 (Batc (None, 256, 256, 256) 1024 \n", + "_________________________________________________________________\n", + "up_sampling2d_6 (UpSampling2 (None, 512, 512, 256) 0 \n", + "_________________________________________________________________\n", + "conv2d_14 (Conv2D) (None, 512, 512, 3) 6915 \n", + "=================================================================\n", + "Total params: 876,419\n", + "Trainable params: 874,627\n", + "Non-trainable params: 1,792\n", + "_________________________________________________________________\n" + ] + } + ], "source": [ "autoencoder.summary()" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "vertical-accident", + "execution_count": 15, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "plot_model(autoencoder, show_shapes=True)" + "optimizer = keras.optimizers.Adam(learning_rate=1e-4)\n", + "loss_fn = tfa.losses.SigmoidFocalCrossEntropy(from_logits=True)" ] }, { "cell_type": "markdown", - "id": "shared-emphasis", "metadata": {}, "source": [ "## Extracting Features from intermediate layers" @@ -330,121 +448,283 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "remarkable-boutique", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# intermediate_layer_model_1 = keras.Model(inputs=autoencoder.inputs,\n", + "# outputs=autoencoder.get_layer('max_pooling2d_1').output)\n", + "# features_1 = intermediate_layer_model_1(train_ds)\n", + "# intermediate_layer_model_2 = keras.Model(inputs=autoencoder.inputs,\n", + "# outputs=autoencoder.get_layer('max_pooling2d_3').output)\n", + "# features_2 = intermediate_layer_model_1(train_ds)\n", + "# intermediate_layer_model_3 = keras.Model(inputs=autoencoder.inputs,\n", + "# outputs=autoencoder.get_layer('max_pooling2d_5').output)\n", + "# features_3 = intermediate_layer_model_1(train_ds)" + ] + }, + { + "cell_type": "markdown", "metadata": {}, + "source": [ + "## Training and testing the model" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "max_pooling2d_1\n", - "max_pooling2d_3\n", - "max_pooling2d_5\n" + "\n", + " Start of epoch 0\n", + "Seen so far: 4 samples\n", + "Seen so far: 404 samples\n", + "Seen so far: 804 samples\n", + "Seen so far: 1204 samples\n", + "Seen so far: 1604 samples\n", + "Seen so far: 2004 samples\n", + "Seen so far: 2404 samples\n", + "Seen so far: 2804 samples\n", + "\n", + " Start of epoch 1\n", + "Seen so far: 4 samples\n", + "Seen so far: 404 samples\n", + "Seen so far: 804 samples\n", + "Seen so far: 1204 samples\n", + "Seen so far: 1604 samples\n", + "Seen so far: 2004 samples\n", + "Seen so far: 2404 samples\n", + "Seen so far: 2804 samples\n" ] } ], "source": [ - "intermediate_layer_model_1 = keras.Model(inputs=autoencoder.inputs,\n", - " outputs=model.get_layer('max_pooling2d_1').output)\n", - "features_1 = intermediate_layer_model_1(train_images)\n", - "intermediate_layer_model_2 = keras.Model(inputs=autoencoder.inputs,\n", - " outputs=model.get_layer('max_pooling2d_3').output)\n", - "features_2 = intermediate_layer_model_1(train_images)\n", - "intermediate_layer_model_3 = keras.Model(inputs=autoencoder.inputs,\n", - " outputs=model.get_layer('max_pooling2d_5').output)\n", - "features_3 = intermediate_layer_model_1(train_images)" + "checkpoint = tf.train.Checkpoint(optimizer=optimizer, model = autoencoder)\n", + "epochs = 2\n", + "for epoch in range(epochs):\n", + " print(\"\\n Start of epoch %d\" % (epoch,))\n", + " for step, x_batch_train in enumerate(train_dataset.take(800)):\n", + " with tf.GradientTape() as tape:\n", + " predictions = autoencoder(x_batch_train, training=True)\n", + " loss_value = loss_fn(predictions, x_batch_train)\n", + " \n", + " grads = tape.gradient(loss_value, autoencoder.trainable_weights)\n", + " optimizer.apply_gradients(zip(grads, autoencoder.trainable_weights))\n", + "# if step&10000 == 0:\n", + "# checkpoint.save(checkpoint_prefix)\n", + " if step%100 == 0:\n", + " print(\"Seen so far: %s samples\" % ((step+1)*4))\n", + " " ] }, { - "cell_type": "markdown", - "id": "bronze-salem", + "cell_type": "code", + "execution_count": 18, "metadata": {}, + "outputs": [], "source": [ - "## Training and testing the model" + "# autoencoder.save('saved_model/AEncoder')" ] }, { "cell_type": "code", - "execution_count": null, - "id": "packed-childhood", + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ - "autoencoder.fit(train_images, train_images, epochs = 1, shuffle = True, verbose=1, validation_data=(val_images, val_images))" + "# autoencoder.save_weights(\"model.h5\")" ] }, { "cell_type": "code", - "execution_count": null, - "id": "aboriginal-computer", + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "decoded_imgs = autoencoder.predict(test_images)" + "# model = keras.models.load_model('./saved_model/AEncoder')" ] }, { - "cell_type": "markdown", - "id": "aware-celebration", + "cell_type": "code", + "execution_count": 21, "metadata": {}, + "outputs": [], "source": [ - "## Comparing test and model created images" + "images_batch_testing = next(iter(test_dataset))\n", + "predict = autoencoder.predict(images_batch_testing)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "ideal-nightmare", + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(4, 512, 512, 3)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "n = 2\n", - "plt.figure(figsize=(32,32))\n", - "for i in range(n):\n", - " # display original\n", - " ax = plt.subplot(3, n, i+1)\n", - " plt.imshow(test_images[i])\n", - " plt.gray()\n", - " ax.get_xaxis().set_visible(False)\n", - " ax.get_yaxis().set_visible(False)\n", - "\n", - " \n", - " # display reconstruction\n", - " ax = plt.subplot(3, n, i+n+1)\n", - " plt.imshow(decoded_imgs[i])\n", - " plt.gray()\n", - " ax.get_xaxis().set_visible(False)\n", - " ax.get_yaxis().set_visible(False)\n", - " \n", - "plt.show()" + "predict.shape" ] }, { - "cell_type": "markdown", - "id": "worldwide-worcester", + "cell_type": "code", + "execution_count": 23, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(512, 512, 3)\n", + "(512, 512, 3)\n", + "(512, 512, 3)\n", + "(512, 512, 3)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "## Visualizing loss" + "show_batch_original(images_batch_testing)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "ongoing-democracy", + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(512, 512, 3)\n", + "(512, 512, 3)\n", + "(512, 512, 3)\n", + "(512, 512, 3)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "print(history.history.keys())\n", - "\n", - "plt.plot(history.history['loss'])\n", - "plt.plot(history.history['val_loss'])\n", - "plt.title('model loss')\n", - "plt.ylabel('loss')\n", - "plt.xlabel('epoch')\n", - "plt.legend(['train', 'validation'], loc='upper right')\n", - "plt.show()" + "def show_batch_predict(predictionss):\n", + " plt.figure(figsize=(10,10))\n", + " for n in range(4):\n", + " ax = plt.subplot(5,5, n+1)\n", + " print(predictionss[n].shape)\n", + " plt.imshow(predictionss[n])\n", + " plt.axis(\"off\")\n", + "show_batch_predict(predict)" ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0.2614248 , 0.31034148, 0.4517802 ],\n", + " [0.29927737, 0.29308647, 0.50266886],\n", + " [0.2527471 , 0.259766 , 0.47063607],\n", + " ...,\n", + " [0.3009634 , 0.28217915, 0.41074643],\n", + " [0.34719342, 0.32580817, 0.5787346 ],\n", + " [0.33189106, 0.24204455, 0.50398844]],\n", + "\n", + " [[0.42969036, 0.56044453, 0.4936702 ],\n", + " [0.8912335 , 0.90387934, 0.8410133 ],\n", + " [0.87755436, 0.919216 , 0.8698472 ],\n", + " ...,\n", + " [0.89966327, 0.90875506, 0.8697271 ],\n", + " [0.9064954 , 0.9032617 , 0.9143692 ],\n", + " [0.6097129 , 0.53572047, 0.62242126]],\n", + "\n", + " [[0.46954745, 0.52433145, 0.4999061 ],\n", + " [0.92554766, 0.92446464, 0.88981855],\n", + " [0.9164764 , 0.9496018 , 0.9162032 ],\n", + " ...,\n", + " [0.9151855 , 0.93526 , 0.89648634],\n", + " [0.89595234, 0.92129153, 0.92021257],\n", + " [0.49219954, 0.501686 , 0.5956709 ]],\n", + "\n", + " ...,\n", + "\n", + " [[0.43906546, 0.39755732, 0.54544264],\n", + " [0.9116539 , 0.85101646, 0.8892077 ],\n", + " [0.9327856 , 0.92487276, 0.91306585],\n", + " ...,\n", + " [0.91551757, 0.94790727, 0.9164805 ],\n", + " [0.8755231 , 0.9129786 , 0.8931245 ],\n", + " [0.4157698 , 0.60212183, 0.4824291 ]],\n", + "\n", + " [[0.41569763, 0.3966468 , 0.47464854],\n", + " [0.85783094, 0.83498174, 0.75382686],\n", + " [0.8967779 , 0.85600764, 0.81343794],\n", + " ...,\n", + " [0.88180125, 0.8887842 , 0.8641388 ],\n", + " [0.8283948 , 0.8775609 , 0.85309345],\n", + " [0.5447991 , 0.53080004, 0.57888925]],\n", + "\n", + " [[0.08242985, 0.21711123, 0.24718131],\n", + " [0.04742079, 0.12068036, 0.10159362],\n", + " [0.03172795, 0.07355574, 0.06271753],\n", + " ...,\n", + " [0.05409776, 0.07111868, 0.05947275],\n", + " [0.06730643, 0.10688517, 0.07274215],\n", + " [0.21980083, 0.1107371 , 0.11687768]]], dtype=float32)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predict[1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -463,7 +743,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.8.5" } }, "nbformat": 4,