ENCODER-MLP-128-64-32-F-C.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ae6d9200",
   "metadata": {},
   "source": [
    "<h3>輸入原影像，經過壓縮轉換，再由轉換壓縮碼，還原成類原圖</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "92fc498c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import absolute_import, division, print_function, unicode_literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dec7388f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "import os\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "895f7f82",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "60287539",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f1eed018",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "\n",
    "from keras.preprocessing.image import load_img\n",
    "from keras.preprocessing.image import img_to_array\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "from keras import layers\n",
    "from keras.models import Model\n",
    "from keras.callbacks import ModelCheckpoint, EarlyStopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8c02da01",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from pylab import rcParams\n",
    "from matplotlib import cm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "561d32fe",
   "metadata": {},
   "source": [
    "<h3>載入影像檔</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f288267b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_image_file(my_image_file, enhanced=False):\n",
    "    global max_dim, kernel, alpha, beta\n",
    "    \n",
    "    if not os.path.exists(my_image_file):\n",
    "        return None\n",
    "        \n",
    "    kernel = numpy.array([[-1, -1, -1], [-1, 11, -1], [-1, -1, -1]])\n",
    "\n",
    "    alpha = 0.6 # Contrast control (1.0-3.0)\n",
    "    beta = 2 # Brightness control (0-100)\n",
    "\n",
    "    _fish_image = cv2.imread(my_image_file, cv2.COLOR_BGR2RGB)\n",
    "    if _fish_image is None:\n",
    "        return None\n",
    "    \n",
    "    if enhanced:\n",
    "        _fish_image = cv2.filter2D(_fish_image, -1, kernel)\n",
    "        _fish_image = cv2.convertScaleAbs(_fish_image.copy(), alpha=alpha, beta=beta)\n",
    "\n",
    "    _fish_image = cv2.resize(_fish_image.copy(), max_dim[:2])\n",
    "    \n",
    "    return _fish_image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d0cf5b8",
   "metadata": {},
   "source": [
    "<h3>顯示影像檔</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b11edb18",
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_image(my_image):\n",
    "    fig, ax = plt.subplots(dpi=120)\n",
    "    ax.imshow(my_image)\n",
    "    ax.axis('off')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "774906ab",
   "metadata": {},
   "source": [
    "<h3>計算原圖與重建差異</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c96ba575",
   "metadata": {},
   "outputs": [],
   "source": [
    "def benchmark(my_diff_image):\n",
    "    diff = 0.0\n",
    "    \n",
    "    for i in range(max_dim[2]):\n",
    "        diff += numpy.sum(numpy.square(my_diff_image))\n",
    "        \n",
    "    return diff**0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d4c9208",
   "metadata": {},
   "source": [
    "<h3>產生影像樣本</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1b40843b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data(train_ratio=0.8, enhanced=False):\n",
    "    global max_dim, image_files\n",
    "\n",
    "    datagen = ImageDataGenerator(rotation_range=45,\n",
    "                                 width_shift_range=[0.1, 0.2],\n",
    "                                 height_shift_range=[0.1, 0.2],\n",
    "                                 horizontal_flip=True\n",
    "    )\n",
    "    \n",
    "    my_images = []\n",
    "\n",
    "    for image_file in image_files:\n",
    "        _image_file = image_file.replace('\\\\', '/')\n",
    "        \n",
    "        _fish_image = read_image_file(_image_file, enhanced)\n",
    "        if _fish_image is None:\n",
    "            print('Not Found:', _image_file)\n",
    "            continue\n",
    "        \n",
    "        my_images.append(numpy.reshape(_fish_image, max_dim))\n",
    "\n",
    "        _fish_img_data = img_to_array(_fish_image)    \n",
    "        _fish_img_data = numpy.expand_dims(_fish_img_data, 0)\n",
    "        \n",
    "        it = datagen.flow(_fish_img_data, batch_size=1)\n",
    "\n",
    "        for i in range(10):\n",
    "            _batch = it.next()\n",
    "            _generated_image = _batch[0].astype('uint8')\n",
    "            \n",
    "            my_images.append(numpy.reshape(_generated_image, max_dim))\n",
    "\n",
    "    my_images = numpy.array(my_images)\n",
    "    numpy.random.shuffle(my_images)\n",
    "    \n",
    "    pos = int(my_images.shape[0] * train_ratio)\n",
    "    return my_images[:pos], my_images[pos:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c812f99",
   "metadata": {},
   "source": [
    "<h3>載入驗證影像檔群</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c41c6dd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_validate_images(my_faint_image_files):\n",
    "    global _max_dim\n",
    "    \n",
    "    my_faint_images = []\n",
    "\n",
    "    for image_file in my_faint_image_files:\n",
    "        _image_file = image_file.replace('\\\\', '/')\n",
    "\n",
    "        _fish_image = read_image_file(_image_file, enhance_flag)\n",
    "\n",
    "        my_faint_images.append(numpy.reshape(_fish_image, max_dim))\n",
    "\n",
    "    my_faint_images = numpy.array(my_faint_images)\n",
    "\n",
    "    my_faint_images = my_faint_images.astype('float32') / 255.\n",
    "\n",
    "    _max_dim = max_dim[0] * max_dim[1] * max_dim[2]\n",
    "    my_faint_images = numpy.reshape(my_faint_images, (my_faint_images.shape[0], _max_dim))\n",
    "\n",
    "    print(my_faint_images.shape)\n",
    "    \n",
    "    return my_faint_images"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c9657e3",
   "metadata": {},
   "source": [
    "<h3>重建驗證影像群</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "01170947",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_validate_images(my_model, my_faint_images):\n",
    "    faint_encoder = Model(inputs=my_model.input, outputs=my_model.get_layer('latent').output)\n",
    "\n",
    "    faint_encoded_imgs = faint_encoder.predict(my_faint_images)\n",
    "    faint_encoded_imgs = faint_encoded_imgs.reshape((len(faint_encoded_imgs), encode_dimension, encode_dimension, 1))\n",
    "\n",
    "    faint_decoded_imgs = my_model.predict(my_faint_images)\n",
    "\n",
    "    print(faint_encoded_imgs.shape, faint_decoded_imgs.shape)\n",
    "    return faint_encoded_imgs, faint_decoded_imgs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17396780",
   "metadata": {},
   "source": [
    "<h3>驗證差異影像檔群</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "009ffa1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def output_predicted_image(my_faint_image, my_faint_encoded_img, my_faint_decoded_img):\n",
    "    fig, (ax0, ax1, ax2, ax3) = plt.subplots(dpi=240, ncols=4)\n",
    "\n",
    "    ax0.imshow(my_faint_image.reshape(max_dim))\n",
    "    ax0.get_xaxis().set_visible(False)\n",
    "    ax0.get_yaxis().set_visible(False)\n",
    "\n",
    "    faint_encoded_img_min = my_faint_encoded_img.min()\n",
    "    faint_encoded_img_max = my_faint_encoded_img.max()\n",
    "    faint_encoded_img_val = (my_faint_encoded_img - faint_encoded_img_min) / (faint_encoded_img_max - faint_encoded_img_min)\n",
    "\n",
    "    ax1.imshow(faint_encoded_img_val.reshape(encode_dimension, encode_dimension), cmap=plt.cm.binary)\n",
    "    ax1.get_xaxis().set_visible(False)\n",
    "    ax1.get_yaxis().set_visible(False)\n",
    "\n",
    "    ax2.imshow(my_faint_decoded_img.reshape(max_dim))\n",
    "    ax2.get_xaxis().set_visible(False)\n",
    "    ax2.get_yaxis().set_visible(False)\n",
    "\n",
    "    faint_diff_image = my_faint_image - my_faint_decoded_img\n",
    "    faint_diff_image_min = faint_diff_image.min()\n",
    "    faint_diff_image_max = faint_diff_image.max()\n",
    "    faint_diff_image_val = (faint_diff_image - faint_diff_image_min) / (faint_diff_image_max - faint_diff_image_min)\n",
    "\n",
    "    ax3.imshow(faint_diff_image_val.reshape(max_dim), cmap=plt.cm.binary)\n",
    "    ax3.get_xaxis().set_visible(False)\n",
    "    ax3.get_yaxis().set_visible(False)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7383dff8",
   "metadata": {},
   "source": [
    "<h3>輸出差異影像檔群</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "95e73075",
   "metadata": {},
   "outputs": [],
   "source": [
    "def output_diff_image(my_faint_image, my_faint_decoded_img):\n",
    "    global max_dim\n",
    "    \n",
    "    fig, ax = plt.subplots(dpi=240)\n",
    "\n",
    "    faint_diff_image = my_faint_image - my_faint_decoded_img\n",
    "    faint_diff_image_min = faint_diff_image.min()\n",
    "    faint_diff_image_max = faint_diff_image.max()\n",
    "    faint_diff_image_val = (faint_diff_image - faint_diff_image_min) / (faint_diff_image_max - faint_diff_image_min)\n",
    "\n",
    "    ax.imshow(faint_diff_image_val.reshape(max_dim), cmap=plt.cm.binary)\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8f2cb30",
   "metadata": {},
   "source": [
    "<h3>隨機顯示原圖/重建/特徵/差異等影像</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "79b00c2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_plot_all():\n",
    "    i = numpy.random.randint(0, faint_decoded_imgs.shape[0], 1)[0]\n",
    "\n",
    "    output_predicted_image(my_faint_images[i], faint_encoded_imgs[i], faint_decoded_imgs[i])\n",
    "    benchmark(faint_diff_image_val.reshape(max_dim))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ed266e5",
   "metadata": {},
   "source": [
    "<h3>隨機顯示差異等影像</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "54da6989",
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_plot_diff():\n",
    "    i = numpy.random.randint(0, faint_decoded_imgs.shape[0], 1)[0]\n",
    "\n",
    "    output_diff_image(my_faint_images[i], faint_decoded_imgs[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ce13e98",
   "metadata": {},
   "source": [
    "<h3>主程式: 環境設定</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "79fc92d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "image_path = 'images/full'\n",
    "max_dim = (256, 256, 3)\n",
    "enhance_flag = False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d572ccd9",
   "metadata": {},
   "source": [
    "<h3>蒐集影像檔目錄群</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2c7895d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "images/full/F007010.jpg\n"
     ]
    }
   ],
   "source": [
    "image_files = [ fn.replace('\\\\', '/') for fn in glob('%s/F*.jpg' % image_path) ]\n",
    "\n",
    "_image_ID = numpy.random.randint(0, len(image_files))\n",
    "print(image_files[_image_ID])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44e508a8",
   "metadata": {},
   "source": [
    "<h3>載入或產生訓練及驗證影像</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7202210f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20213, 196608)\n"
     ]
    }
   ],
   "source": [
    "mem_file = 'FULL_TRAIN.npy'\n",
    "x_train = None \n",
    "\n",
    "if os.path.exists(mem_file):\n",
    "    x_train = numpy.load(mem_file)  \n",
    "    print(x_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "dee11488",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5054, 196608)\n"
     ]
    }
   ],
   "source": [
    "mem_file = 'FULL_TEST.npy'\n",
    "x_test = None\n",
    "\n",
    "if os.path.exists(mem_file):\n",
    "    x_test = numpy.load(mem_file)\n",
    "    print(x_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f218ea82",
   "metadata": {},
   "outputs": [],
   "source": [
    "if x_train is None or x_test is None:\n",
    "    x_train, x_test = load_data(train_ratio=0.8, enhanced=enhance_flag)\n",
    "    \n",
    "    x_train = x_train.astype('float32') / 255.\n",
    "    x_test = x_test.astype('float32') / 255.\n",
    "    \n",
    "    x_train = x_train.reshape((x_train.shape[0], numpy.prod(x_train.shape[1:])))\n",
    "    x_test = x_test.reshape((x_test.shape[0], numpy.prod(x_test.shape[1:])))\n",
    "    \n",
    "    numpy.save('FULL_TRAIN.npy', x_train)\n",
    "    numpy.save('FULL_TEST.npy', x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b0a097e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((20213, 196608), (5054, 196608))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.shape, x_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "529300c7",
   "metadata": {},
   "source": [
    "<h3>參數設置</h3>\n",
    "<p>$$壓縮率: \\frac {65536}{32} = 2048$$</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "39111b81",
   "metadata": {},
   "outputs": [],
   "source": [
    "encode_dimension = 12\n",
    "encoding_dim = encode_dimension * encode_dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f935e4ca",
   "metadata": {},
   "source": [
    "<h3>載入或建立訓練模型</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3f57d751",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_saved_file = 'models/MLP-C-F-0-128-64-32.hdf5'\n",
    "autoencoder = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c28c6e31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"autoencoder\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input (InputLayer)           [(None, 196608)]          0         \n",
      "_________________________________________________________________\n",
      "encoded_128 (Dense)          (None, 128)               25165952  \n",
      "_________________________________________________________________\n",
      "encoded_64 (Dense)           (None, 64)                8256      \n",
      "_________________________________________________________________\n",
      "encoded_32 (Dense)           (None, 32)                2080      \n",
      "_________________________________________________________________\n",
      "latent (Dense)               (None, 144)               4752      \n",
      "_________________________________________________________________\n",
      "decoded_32 (Dense)           (None, 32)                4640      \n",
      "_________________________________________________________________\n",
      "decoded_64 (Dense)           (None, 64)                2112      \n",
      "_________________________________________________________________\n",
      "decoded_128 (Dense)          (None, 128)               8320      \n",
      "_________________________________________________________________\n",
      "output (Dense)               (None, 196608)            25362432  \n",
      "=================================================================\n",
      "Total params: 50,558,544\n",
      "Trainable params: 50,558,544\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "if not os.path.exists(model_saved_file):\n",
    "    num_of_epoch = 16\n",
    "    num_of_batch_size = 8\n",
    "\n",
    "    input_img = keras.Input(shape=(x_train.shape[1],), name='input')\n",
    "\n",
    "    encoded_128 = layers.Dense(128, name='encoded_128', activation='relu')(input_img)\n",
    "    encoded_64 = layers.Dense(64, name='encoded_64', activation='relu')(encoded_128)\n",
    "    encoded_32 = layers.Dense(32, name='encoded_32', activation='relu')(encoded_64)\n",
    "    encoded = layers.Dense(encoding_dim, name='latent', activation='relu')(encoded_32)\n",
    "\n",
    "    decoded_32 = layers.Dense(32, name='decoded_32', activation='relu')(encoded)\n",
    "    decoded_64 = layers.Dense(64, name='decoded_64', activation='relu')(decoded_32)\n",
    "    decoded_128 = layers.Dense(128, name='decoded_128', activation='relu')(decoded_64)\n",
    "    decoded = layers.Dense(x_train.shape[1], name='output', activation='sigmoid')(decoded_128)\n",
    "\n",
    "    autoencoder = keras.Model(input_img, decoded, name='autoencoder')\n",
    "\n",
    "    print(autoencoder.summary())\n",
    "\n",
    "    encoder = keras.Model(input_img, encoded)\n",
    "    encoded_input = keras.Input(shape=(encoding_dim,))\n",
    "\n",
    "    decoder_layer_32 = autoencoder.layers[-4]\n",
    "    decoder_layer_64 = autoencoder.layers[-3]\n",
    "    decoder_layer_128 = autoencoder.layers[-2]\n",
    "    decoder_layer = autoencoder.layers[-1]\n",
    "\n",
    "    decoder = keras.Model(encoded_input, \n",
    "                          decoder_layer(decoder_layer_128(\n",
    "                              decoder_layer_64(\n",
    "                              decoder_layer_32(encoded_input)))))\n",
    "\n",
    "    autoencoder.compile(optimizer='adam', loss='binary_crossentropy')\n",
    "\n",
    "    checkpointer = ModelCheckpoint(\n",
    "        filepath=model_aved_file, \n",
    "        monitor=\"val_loss\", verbose=1, \n",
    "        save_best_only=True, mode='auto'\n",
    "    )\n",
    "\n",
    "    earlyStop = EarlyStopping(monitor='val_loss', patience=50)\n",
    "\n",
    "\n",
    "    score = autoencoder.fit(x_train, x_train,\n",
    "                            epochs=num_of_epoch,\n",
    "                            batch_size=num_of_batch_size,\n",
    "                            shuffle=True,\n",
    "                            validation_data=(x_test, x_test),\n",
    "                            callbacks=[checkpointer, earlyStop]\n",
    "                           )\n",
    "\n",
    "    best_iteration = numpy.argmin(score.history['val_loss']) + 1\n",
    "\n",
    "    val_scores = score.history['val_loss'][0:best_iteration]\n",
    "    train_scores = score.history['loss'][0:best_iteration]\n",
    "\n",
    "    fig, ax = plt.subplots(dpi=120)\n",
    "\n",
    "    ax.plot(val_scores, label='val_loss')\n",
    "    ax.plot(train_scores, label='train_loss')\n",
    "\n",
    "    plt.legend(loc='upper right')\n",
    "    plt.show()\n",
    "else:\n",
    "    autoencoder = keras.models.load_model(model_saved_file)\n",
    "    print(autoencoder.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a8911c1",
   "metadata": {},
   "source": [
    "<h3>蒐集驗證影像檔目錄群</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "913ffd24",
   "metadata": {},
   "outputs": [],
   "source": [
    "faint_image_path = 'D:/Projects/ComputerVision/ObjectDetection/Fish/source_images'\n",
    "faint_image_files = sorted(glob('%s/F*.jpg' % faint_image_path))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2489bced",
   "metadata": {},
   "source": [
    "<h3>影像邊緣偵測參數</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f356e584",
   "metadata": {},
   "outputs": [],
   "source": [
    "sobel_filter = 7\n",
    "sobel_scale = 1.2\n",
    "sobel_delta = 0.2\n",
    "sobel_weight = 0.75\n",
    "\n",
    "sobel_ddepth = cv2.CV_16S"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94a903fc",
   "metadata": {},
   "source": [
    "<h3>產生驗證影像檔群</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "1e59cba0",
   "metadata": {},
   "outputs": [],
   "source": [
    "sobel_detect = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "5d5d97f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 196608)\n",
      "(64, 12, 12, 1) (64, 196608)\n",
      "(64, 196608)\n",
      "(64, 12, 12, 1) (64, 196608)\n",
      "(64, 196608)\n",
      "(64, 12, 12, 1) (64, 196608)\n",
      "(64, 196608)\n",
      "(64, 12, 12, 1) (64, 196608)\n",
      "(64, 196608)\n",
      "(64, 12, 12, 1) (64, 196608)\n"
     ]
    }
   ],
   "source": [
    "start_position_list = [0, 64, 128, 192, 256]\n",
    "\n",
    "for j in range(len(start_position_list)):\n",
    "    start_pos = start_position_list[j]\n",
    "    \n",
    "    my_faint_images = load_validate_images(faint_image_files[start_pos:start_pos+64])\n",
    "    faint_encoded_imgs, faint_decoded_imgs = predict_validate_images(autoencoder, my_faint_images)\n",
    "\n",
    "    for i in range(my_faint_images.shape[0]):\n",
    "        my_faint_image = my_faint_images[i]\n",
    "        my_faint_encoded_img = faint_encoded_imgs[i]\n",
    "        my_faint_decoded_img = faint_decoded_imgs[i]\n",
    "\n",
    "        faint_diff_image = my_faint_image - my_faint_decoded_img\n",
    "        faint_diff_image_min = faint_diff_image.min()\n",
    "        faint_diff_image_max = faint_diff_image.max()\n",
    "        faint_diff_image_val = (faint_diff_image - faint_diff_image_min) / (faint_diff_image_max - faint_diff_image_min)\n",
    "        faint_diff_image_val = faint_diff_image_val.reshape(max_dim)\n",
    "\n",
    "        output_path = 'DIFF'\n",
    "        if sobel_detect:\n",
    "            output_path = 'DIFF2'\n",
    "\n",
    "            src = cv2.GaussianBlur(faint_diff_image_val, (sobel_filter, sobel_filter), 0)  \n",
    "            gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)   \n",
    "\n",
    "            grad_x = cv2.Sobel(gray, sobel_ddepth, 1, 0, ksize=sobel_filter, \n",
    "                               scale=sobel_scale, delta=sobel_delta, borderType=cv2.BORDER_DEFAULT)\n",
    "\n",
    "            grad_y = cv2.Sobel(gray, sobel_ddepth, 0, 1, ksize=sobel_filter, \n",
    "                               scale=sobel_scale, delta=sobel_delta, borderType=cv2.BORDER_DEFAULT)\n",
    "\n",
    "            abs_grad_x = cv2.convertScaleAbs(grad_x)\n",
    "            abs_grad_y = cv2.convertScaleAbs(grad_y)    \n",
    "\n",
    "            grad = cv2.addWeighted(abs_grad_x, sobel_weight, abs_grad_y, sobel_weight, 0)\n",
    "            faint_diff_image_val = grad\n",
    "\n",
    "        fig, ax = plt.subplots(dpi=300)\n",
    "        \n",
    "        ax.axis(\"off\")\n",
    "        ax.imshow(faint_diff_image_val, cmap=plt.cm.binary)\n",
    "               \n",
    "        output_file = '%s/D%06d.jpg' % (output_path, i+start_pos)\n",
    "        if os.path.exists(output_file):\n",
    "            os.remove(output_file)\n",
    "            \n",
    "        fig.savefig(output_file, bbox_inches='tight',pad_inches=0)\n",
    "        plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7eb50ba9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}