[Final-Article]stegomalware_detector.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import\n",
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import sklearn\n",
    "import glob\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "from skimage.transform import resize\n",
    "\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau\n",
    "from tensorflow.keras.optimizers import Adam, RMSprop\n",
    "\n",
    "from sklearn.metrics import *\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "from stego_classifier_extended import *\n",
    "from stego_detector_extended import *\n",
    "import random as rn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Utils\n",
    "\n",
    "def extract_1_lsb_features(dataset):\n",
    "    lsb_training_set = dataset & 1\n",
    "    lsb_training_set = lsb_training_set.reshape(dataset.shape[0], dataset.shape[1]*dataset.shape[2]*dataset.shape[3])\n",
    "    return lsb_training_set\n",
    "\n",
    "#convert to binary\n",
    "def messageToBinary(message):\n",
    "  if type(message) == str:\n",
    "    return ''.join([ format(ord(i), \"08b\") for i in message ])\n",
    "  elif type(message) == bytes or type(message) == np.ndarray:\n",
    "    return [ format(i, \"08b\") for i in message ]\n",
    "  elif type(message) == int or type(message) == np.uint8:\n",
    "    return format(message, \"08b\")\n",
    "  else:\n",
    "    raise TypeError(\"Input type not supported\")\n",
    "  \n",
    "#extract k lsb for each channel\n",
    "def extract_k_lsb_features(data, k=4):\n",
    "    count = 0\n",
    "    lsb_training = []\n",
    "    for img in data:\n",
    "        count = count + 1\n",
    "        if count % 50 == 0:\n",
    "            print(count)\n",
    "        binary_data = []\n",
    "        for values in img:\n",
    "            for pixel in values:\n",
    "                r, g, b = messageToBinary(pixel)\n",
    "                for i in range(1,k+1):\n",
    "                    binary_data.append(int(r[-1-i+1]))  # extracting data from the least significant bit of red pixel\n",
    "                    binary_data.append(int(g[-1-i+1]))  # extracting data from the least significant bit of green pixel\n",
    "                    binary_data.append(int(b[-1-i+1]))  # extracting data from the least significant bit of blue pixel\n",
    "                # split by 8-bits\n",
    "\n",
    "        lsb_training.append(np.array(binary_data))\n",
    "        \n",
    "\n",
    "    return np.array(lsb_training)\n",
    "\n",
    "# load images in the image_path\n",
    "def load_images(image_path):\n",
    "    images = []\n",
    "    for f_name in sorted(glob.glob(image_path + '/*.png')):\n",
    "        img = np.asarray(Image.open(f_name).convert('RGB'))\n",
    "        images.append(img)\n",
    "    return images\n",
    "\n",
    "#convert an image into array\n",
    "def convert_np_array(vector):\n",
    "    result = []\n",
    "    for v in vector:\n",
    "        result.append(v)\n",
    "    return np.array(result)\n",
    "\n",
    "#laod data\n",
    "def load_data(main_data_folder, usage_folder_name, legit_folder_name, stego_folder_names):\n",
    "    \n",
    "    data_path = os.path.join(main_data_folder, usage_folder_name)\n",
    "    data_to_load = []\n",
    "    num_stego_images_for_class = []\n",
    "    data_to_load.append(convert_np_array(load_images(os.path.join(data_path,legit_folder_name))))\n",
    "    for stego_folder_name in stego_folder_names:\n",
    "        stego_images = convert_np_array(load_images(os.path.join(data_path,stego_folder_name)))\n",
    "        num_stego_images_for_class.append(stego_images.shape[0])\n",
    "        data_to_load.append(stego_images)\n",
    "\n",
    "    num_legit_images = data_to_load[0].shape[0]\n",
    "    print(\"#legit images\", data_to_load[0].shape[0])\n",
    "    print(\"#stego images\", num_stego_images_for_class)\n",
    "\n",
    "    data_to_load = np.concatenate(data_to_load)\n",
    "    print(\"data shape: \", data_to_load.shape)\n",
    "\n",
    "    print(\"done\")\n",
    "    \n",
    "    return data_to_load, num_legit_images, np.array(num_stego_images_for_class)\n",
    "\n",
    "#create target variable with labels\n",
    "def create_target_labels(legits, stego_type_number):\n",
    "    target = []\n",
    "    i = 0\n",
    "    target.append(np.zeros(legits, dtype=np.int8))\n",
    "    for current_stego in stego_type_number:\n",
    "        target.append(np.ones(current_stego, dtype=np.int8)+i)\n",
    "        i=i+1\n",
    "    return np.concatenate(target)\n",
    "\n",
    "#create target variable\n",
    "def create_target(legits, stegos):\n",
    "    y_legit = np.zeros(legits, dtype=np.int8)\n",
    "    y_stego = np.ones(stegos, dtype=np.int8)\n",
    "    return np.concatenate([y_legit, y_stego])\n",
    "\n",
    "def refresh_riproducibility(seed):\n",
    "   \n",
    "    #set seed \n",
    "\n",
    "    #Python SEED\n",
    "    os.environ['PYTHONHASHSEED'] = '0'\n",
    "    \n",
    "    #numpy seed\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    #tf seed\n",
    "    tf.random.set_seed(seed)\n",
    "    \n",
    "    #rn seed\n",
    "    rn.seed(seed)\n",
    "    \n",
    "    tf.config.threading.set_inter_op_parallelism_threads(1)\n",
    "    tf.config.threading.set_intra_op_parallelism_threads(1)\n",
    "    \n",
    "    #\n",
    "    from tensorflow.compat.v1.keras import backend as K\n",
    "    \n",
    "    #sess\n",
    "    sess = tf.compat.v1.get_default_session()\n",
    "    K.set_session(sess)\n",
    "    \n",
    "    #tf seed\n",
    "    tf.compat.v1.set_random_seed(seed)\n",
    "    \n",
    "    #os.environ['KERAS_BACKEND'] = \"tensorflow\"\n",
    "    os.environ['TF_DETERMINISTIC_OPS'] = '1'\n",
    "    os.environ['TF_CUDNN_DETERMINISTIC'] = '1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Parameters ---------------------------\n",
    "\n",
    "#data_folder =  \"/\" # Debug data folder: \"./data/debug\"\n",
    "\n",
    "data_folder = \"./Dataset/dataset\"\n",
    "#data_folder = \"./Dataset/subsample\"\n",
    "legit_folder = 'legit'\n",
    "#stego_folders = ['LSB_stego_php','LSB_stego_url']\n",
    "stego_folders = ['LSB_stego_url','LSB_stego_eth','LSB_stego_html','LSB_stego_js','LSB_stego_ps']\n",
    "cwd = './'\n",
    "model_space = 'output/models-separate_k1'\n",
    "seed = 230782\n",
    "k_lsb = 1 # we use only 2-bits\n",
    "#------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stego Malware Detection Task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#legit images 4000\n",
      "#stego images [2412, 2473, 2284, 2363, 2468]\n",
      "data shape:  (16000, 512, 512, 3)\n",
      "done\n",
      "#training shape, neg, pos:  (16000, 512, 512, 3) 4000 12000\n",
      "#num classes:  6\n"
     ]
    }
   ],
   "source": [
    "#loading training set\n",
    "training_set, num_training_legit, num_training_stego_for_class  = load_data(data_folder, \"training\", legit_folder, stego_folders)\n",
    "num_training_stego = np.sum(num_training_stego_for_class)\n",
    "num_targets = len(num_training_stego_for_class)+1\n",
    "print(\"#training shape, neg, pos: \", training_set.shape, num_training_legit, num_training_stego)\n",
    "print(\"#num classes: \", num_targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#lsb extraction\n",
    "training_set = extract_1_lsb_features(training_set)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training set ready\n"
     ]
    }
   ],
   "source": [
    "y_train = create_target(num_training_legit, num_training_stego)\n",
    "print(\"training set ready\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#legit images 2000\n",
      "#stego images [1218, 1193, 1162, 1214, 1213]\n",
      "data shape:  (8000, 512, 512, 3)\n",
      "done\n",
      "#validation shape, neg, pos:  (8000, 512, 512, 3) 2000 6000\n",
      "validation set ready\n"
     ]
    }
   ],
   "source": [
    "#loading validation set\n",
    "validation, num_val_legit, num_val_stego_for_class  = load_data(data_folder, \"validation\", legit_folder, stego_folders)\n",
    "num_val_stego = np.sum(num_val_stego_for_class)\n",
    "print(\"#validation shape, neg, pos: \", validation.shape, num_val_legit, num_val_stego)\n",
    "\n",
    "#lsb extraction\n",
    "validation = extract_1_lsb_features(validation)\n",
    "y_val = create_target(num_val_legit, num_val_stego)\n",
    "print(\"validation set ready\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#init classifier\n",
    "#classifier = StegoClassifierExtended(training_set.shape[1], num_targets)\n",
    "#detector = StegoDetectorExtended(training_set.shape[1])\n",
    "\n",
    "#compile classifier\n",
    "#classifier.compile(loss='categorical_crossentropy', optimizer=RMSprop(learning_rate=1e-3), metrics=['accuracy'])\n",
    "#detector.compile(loss='binary_crossentropy', optimizer=RMSprop(learning_rate=1e-3), metrics=['accuracy'])\n",
    "\n",
    "#init callbacks\n",
    "#model_path = os.path.join(cwd, model_space, 'best_model_stego_classification')\n",
    "#print(\"best model path: \", model_path)\n",
    "#check = ModelCheckpoint(model_path, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=True, mode='min')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#model_path = os.path.join(cwd, model_space, 'best_model_stego_detection')\n",
    "#print(\"best model path: \", model_path)\n",
    "#check = ModelCheckpoint(model_path, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=True, mode='min')\n",
    "#opt = ReduceLROnPlateau(monitor='val_loss', patience=3, min_lr=1e-9, factor=0.01, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /tmp/ipykernel_10414/683761624.py:120: The name tf.keras.backend.set_session is deprecated. Please use tf.compat.v1.keras.backend.set_session instead.\n",
      "\n",
      "best model path:  ./output/models-separate_k1/best_model_stego_detection\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-10 11:57:03.829312: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n",
      "2022-06-10 11:57:03.829343: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: b44220ace66e\n",
      "2022-06-10 11:57:03.829351: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: b44220ace66e\n",
      "2022-06-10 11:57:03.829448: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.103.1\n",
      "2022-06-10 11:57:03.829576: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.103.1\n",
      "2022-06-10 11:57:03.829586: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.103.1\n",
      "2022-06-10 11:57:03.829840: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-06-10 11:57:03.858979: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 12582912000 exceeds 10% of free system memory.\n",
      "2022-06-10 11:57:07.039738: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 12582912000 exceeds 10% of free system memory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "63/63 [==============================] - ETA: 0s - loss: 0.5934 - accuracy: 0.6546"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-10 12:03:01.377031: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 6291456000 exceeds 10% of free system memory.\n",
      "2022-06-10 12:03:02.378655: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 6291456000 exceeds 10% of free system memory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63/63 [==============================] - 374s 6s/step - loss: 0.5934 - accuracy: 0.6546 - val_loss: 0.4423 - val_accuracy: 0.7491 - lr: 0.0010\n",
      "Epoch 2/20\n",
      "63/63 [==============================] - ETA: 0s - loss: 0.4683 - accuracy: 0.7252"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-10 12:09:08.622878: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 6291456000 exceeds 10% of free system memory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63/63 [==============================] - 358s 6s/step - loss: 0.4683 - accuracy: 0.7252 - val_loss: 0.5081 - val_accuracy: 0.7326 - lr: 0.0010\n",
      "Epoch 3/20\n",
      "63/63 [==============================] - 350s 6s/step - loss: 0.4293 - accuracy: 0.7462 - val_loss: 0.5291 - val_accuracy: 0.7220 - lr: 0.0010\n",
      "Epoch 4/20\n",
      "63/63 [==============================] - 364s 6s/step - loss: 0.3843 - accuracy: 0.7906 - val_loss: 0.3331 - val_accuracy: 0.8384 - lr: 0.0010\n",
      "Epoch 5/20\n",
      "63/63 [==============================] - 356s 6s/step - loss: 0.3202 - accuracy: 0.8391 - val_loss: 0.4085 - val_accuracy: 0.7916 - lr: 0.0010\n",
      "Epoch 6/20\n",
      "63/63 [==============================] - 358s 6s/step - loss: 0.2540 - accuracy: 0.8832 - val_loss: 0.1954 - val_accuracy: 0.9391 - lr: 0.0010\n",
      "Epoch 7/20\n",
      "63/63 [==============================] - 338s 5s/step - loss: 0.1959 - accuracy: 0.9193 - val_loss: 0.2533 - val_accuracy: 0.8978 - lr: 0.0010\n",
      "Epoch 8/20\n",
      "63/63 [==============================] - 345s 5s/step - loss: 0.1515 - accuracy: 0.9392 - val_loss: 0.4137 - val_accuracy: 0.8599 - lr: 0.0010\n",
      "Epoch 9/20\n",
      "63/63 [==============================] - 348s 6s/step - loss: 0.1297 - accuracy: 0.9508 - val_loss: 0.3655 - val_accuracy: 0.8775 - lr: 0.0010\n",
      "Epoch 10/20\n",
      "63/63 [==============================] - 347s 6s/step - loss: 0.0843 - accuracy: 0.9693 - val_loss: 0.1327 - val_accuracy: 0.9770 - lr: 1.0000e-05\n",
      "Epoch 11/20\n",
      "63/63 [==============================] - 348s 6s/step - loss: 0.0567 - accuracy: 0.9854 - val_loss: 0.1323 - val_accuracy: 0.9833 - lr: 1.0000e-05\n",
      "Epoch 12/20\n",
      "63/63 [==============================] - 359s 6s/step - loss: 0.0444 - accuracy: 0.9897 - val_loss: 0.1465 - val_accuracy: 0.9803 - lr: 1.0000e-05\n",
      "Epoch 13/20\n",
      "63/63 [==============================] - 359s 6s/step - loss: 0.0355 - accuracy: 0.9926 - val_loss: 0.1412 - val_accuracy: 0.9859 - lr: 1.0000e-05\n",
      "Epoch 14/20\n",
      "63/63 [==============================] - 349s 6s/step - loss: 0.0297 - accuracy: 0.9946 - val_loss: 0.1417 - val_accuracy: 0.9884 - lr: 1.0000e-05\n",
      "Epoch 15/20\n",
      "63/63 [==============================] - 348s 6s/step - loss: 0.0286 - accuracy: 0.9951 - val_loss: 0.1305 - val_accuracy: 0.9918 - lr: 1.0000e-07\n",
      "Epoch 16/20\n",
      "63/63 [==============================] - 329s 5s/step - loss: 0.0278 - accuracy: 0.9947 - val_loss: 0.1262 - val_accuracy: 0.9939 - lr: 1.0000e-07\n",
      "Epoch 17/20\n",
      "63/63 [==============================] - 357s 6s/step - loss: 0.0274 - accuracy: 0.9956 - val_loss: 0.1238 - val_accuracy: 0.9950 - lr: 1.0000e-07\n",
      "Epoch 18/20\n",
      "63/63 [==============================] - 353s 6s/step - loss: 0.0280 - accuracy: 0.9946 - val_loss: 0.1229 - val_accuracy: 0.9954 - lr: 1.0000e-07\n",
      "Epoch 19/20\n",
      "63/63 [==============================] - 364s 6s/step - loss: 0.0276 - accuracy: 0.9954 - val_loss: 0.1228 - val_accuracy: 0.9955 - lr: 1.0000e-07\n",
      "Epoch 20/20\n",
      "63/63 [==============================] - 367s 6s/step - loss: 0.0288 - accuracy: 0.9944 - val_loss: 0.1224 - val_accuracy: 0.9956 - lr: 1.0000e-07\n",
      "Total Prediction Time:7140002\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "refresh_riproducibility(seed)\n",
    "\n",
    "#init classifier\n",
    "#classifier = StegoClassifierExtended(training_set.shape[1], num_targets)\n",
    "detector = StegoDetectorExtended(training_set.shape[1])\n",
    "\n",
    "#compile classifier\n",
    "#classifier.compile(loss='categorical_crossentropy', optimizer=RMSprop(learning_rate=1e-3), metrics=['accuracy'])\n",
    "detector.compile(loss='binary_crossentropy', optimizer=RMSprop(learning_rate=1e-3), metrics=['accuracy'])\n",
    "\n",
    "model_path = os.path.join(cwd, model_space, 'best_model_stego_detection')\n",
    "print(\"best model path: \", model_path)\n",
    "check = ModelCheckpoint(model_path, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=True, mode='min')\n",
    "opt = ReduceLROnPlateau(monitor='val_loss', patience=3, min_lr=1e-9, factor=0.01, verbose=0)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "start_time = int(round(time.time() * 1000))\n",
    "\n",
    "\n",
    "#training model\n",
    "history =   detector.fit(training_set, y_train, batch_size=256, epochs=20, \n",
    "                         validation_data=(validation, y_val), callbacks=[check, opt], verbose=1)\n",
    "\n",
    "#history =   detector.fit(training_set, y_train, batch_size=256, epochs=20, \n",
    "#                         validation_data=(training_set, y_train), callbacks=[check, opt], verbose=1)\n",
    "\n",
    "#training model\n",
    "#history = classifier.fit(training_set, ohe_y_train, batch_size=256, epochs=20, \n",
    "#                         validation_data=(validation, ohe_y_val), callbacks=[check, opt], verbose=1)\n",
    "\n",
    "end_time = int(round(time.time() * 1000))\n",
    "total_time = end_time - start_time\n",
    "#print(start_time)\n",
    "#print(end_time)\n",
    "print('Total Prediction Time:'+str(total_time))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Total Prediction Time:360956 \\n\n",
    "Total Prediction Time:445351 \n",
    "--------------------------------\n",
    "Total Prediction Time:383511\n",
    "Total Prediction Time:483368"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        Loss  epoch\n",
      "0   0.593369      1\n",
      "1   0.468309      2\n",
      "2   0.429312      3\n",
      "3   0.384317      4\n",
      "4   0.320199      5\n",
      "5   0.253961      6\n",
      "6   0.195914      7\n",
      "7   0.151467      8\n",
      "8   0.129726      9\n",
      "9   0.084342     10\n",
      "10  0.056660     11\n",
      "11  0.044403     12\n",
      "12  0.035460     13\n",
      "13  0.029731     14\n",
      "14  0.028556     15\n",
      "15  0.027773     16\n",
      "16  0.027441     17\n",
      "17  0.027997     18\n",
      "18  0.027579     19\n",
      "19  0.028830     20\n"
     ]
    }
   ],
   "source": [
    "type(history.history)\n",
    "his = history.history['loss']\n",
    "df_his = pd.DataFrame(data=his, columns=[\"Loss\"])\n",
    "df_his['epoch'] = range(1, len(df_his) + 1)\n",
    "print(df_his)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./output/models-separate_k1/history\n"
     ]
    }
   ],
   "source": [
    "#Save History\n",
    "file_history = os.path.join(cwd, model_space, 'history')\n",
    "print(file_history)\n",
    "np.save(file_history,history.history)\n",
    "\n",
    "# Load History\n",
    "#history_read=np.load(file_history+'.npy', allow_pickle='TRUE').item()\n",
    "#history_read"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bmsa/env-max/lib/python3.8/site-packages/seaborn/categorical.py:3717: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n",
      "  warnings.warn(msg)\n",
      "/home/bmsa/env-max/lib/python3.8/site-packages/seaborn/categorical.py:3723: UserWarning: The `size` parameter has been renamed to `height`; please update your code.\n",
      "  warnings.warn(msg, UserWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "#print history loss\n",
    "sns.set()\n",
    "sns.set(style='whitegrid', font_scale = 1.2)\n",
    "#sns.set_style(\"darkgrid\")\n",
    "#sns.set_context(\"paper\")\n",
    "\n",
    "rc = {'axes.facecolor':'white',\n",
    "      'axes.grid' : True,\n",
    "      'grid.color': '.8',\n",
    "      #'font.family':'Times New Roman',\n",
    "      'font.height' : 16}\n",
    "#plt.rcParams.update(rc)\n",
    "#sns.set(font_scale = 1.1)\n",
    "\n",
    "g = sns.factorplot(x ='epoch', y ='Loss', data = df_his,\n",
    "               legend_out = False, size=4, aspect=1.5)\n",
    "g.set(yscale='log')\n",
    "#g.fig.subplots_adjust(top=0.95)\n",
    "g.fig.suptitle('Model Loss')\n",
    "\n",
    "g.axes[0,0].set_xlabel('Number of Epochs')\n",
    "plt.xticks([0,4,9,14,19,24]) \n",
    "plt.grid(True, which=\"both\",ls=\"-\",c='#D3D3D3')\n",
    "sns.despine(bottom = False, left = False, right=False, top=False)\n",
    "\n",
    "new_labels = ['Stego Classifier']\n",
    "plt.tight_layout() \n",
    "\n",
    "plt.savefig('output/training_loss.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bmsa/env-max/lib/python3.8/site-packages/seaborn/categorical.py:3717: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n",
      "  warnings.warn(msg)\n",
      "/home/bmsa/env-max/lib/python3.8/site-packages/seaborn/categorical.py:3723: UserWarning: The `size` parameter has been renamed to `height`; please update your code.\n",
      "  warnings.warn(msg, UserWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ8AAAEZCAYAAABICyhRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAyz0lEQVR4nO3deVyU5d4/8M8MwoDDgKIEgoqiDmiAbO4ZLkfTk/pYpiK5pdghNcvAJbNFT3k0Tq71UIl5MjTcSnM5WlamqCgQplMoLiQwKm4gwzYDzP37g4f5OQ0go8w9iJ/36+Ur57qv+5rvXA18vHeJIAgCiIiIRCS1dgFERPT4YfgQEZHoGD5ERCQ6hg8REYmO4UNERKJj+BARkegYPvTYW7hwIQYNGvRA6548eRI+Pj44efJkA1dF1LQxfMjqqn+B+/j4YP369TX2+eKLLwx9HtVf9IMGDcKECROsXQZRo8DwoUZDJpPhu+++q3HZrl27IJPJRK6IiCyF4UONxsCBA5GZmYmMjAyj9nPnzuH8+fMPvGuMiBofhg81Gn369IGrqyt2795t1L5792488cQT6NOnT43rXbp0Ca+++ip69uyJgIAAPPfcc9i1a1eNff/zn/9g8ODB8Pf3x+jRo/Hzzz/XWs+pU6cwbdo0hISEICAgAC+88AIOHTr0wJ+vvk6fPo1p06YhODgYgYGBCA8Pxy+//GLS7+DBgxg3bhxCQ0MRGBiIIUOG4O233za7D5E1MHyo0bCxscHIkSOxd+9eVFZWAgAqKyuxZ88ejBgxAlKp6df1ypUrCA8Px4kTJzBhwgRER0fDzs4OCxYswIYNG4z6xsXF4V//+hfc3d0xb9489OvXD9HR0fj9999Nxj148CCmTp2K0tJSzJ49GzExMbCxscGsWbOwZ88ey0wAgLS0NEyaNAkXL17E9OnT8eqrr0Kj0eAf//gH9u/fb+h34sQJvPbaa5DJZHj99dexcOFCDB06FGlpaWb1IbIagcjKkpOTBaVSKWzbtk3IyMgQlEql8MsvvwiCIAhHjhwRlEqlcO7cOWHbtm2CUqkUkpOTDevOmTNH8PHxEc6cOWNo02q1wgsvvCD4+/sLt2/fFgRBEO7cuSP4+fkJ48ePF8rLyw19Dx8+LCiVSmHgwIGGtpKSEqFnz57CrFmzjOqsqKgQXnjhBeGpp54SKisrjWq/t6baDBw4UAgPD6+zz5gxY4Tu3bsLarXa0FZYWCgMGDBA6Nevn6DT6QRBEIQPPvhACA4ONvosf1WfPkTWwi0falR8fX3h4+Nj2PW2a9cuQ9tfVVZW4siRI+jduzf8/f0N7XZ2dpgyZQq0Wi2OHTsGADh+/Dh0Oh0mTpyIZs2aGfqGhYWhU6dORuMeO3YMBQUFGD16NO7cuWP4c/fuXYSFheHGjRu4dOlSg3/2mzdv4uzZs3j22Wfh4eFhaFcoFAgPDzcsBwAnJyeUlpbi6NGjEGq5MX19+hBZS7P7dyES1//8z/9g3bp1yMvLw48//og5c+bU2O/OnTsoKSkxCQ8A6Ny5MwAgNzcXAKBWqwEAHTt2NOnbsWNHo5McsrKyAACzZs2qtcbbt2+jS5cu9fxE9VNdY02fp7otNzcXwcHBiIiIwMGDBxEVFYVWrVqhd+/eGDhwIIYNGwZbW1sAqFcfImtp0uGj1+tRXFwMW1tbSCQSa5dDtSgvLzf8V6vVYujQofjoo48QExMDnU6HoUOHQqvVmvTT6XQAqraAtFqt0ZjVyyoqKqDValFRUWFo/2tfvV4PQRAM7dV9Fy9ejPbt29dYs7e3d4011UUQBKP3+au/1nyv6pqql8nlciQmJuLUqVM4duwYTpw4gX379mH9+vX48ssv0bx583r1IbIUQRBQXl4OuVxe4/HaJh0+xcXFyMzMtHYZdB/VWxpXr16FSqUCAHTr1g2nTp1CQEAA8vLykJeXh6tXrxr6Ozg4QK/XQyaT4cyZM4b1qh0/fhxA1Q+ASqUynMCQlJQEvV5v1Pf8+fPQ6XQmY9y9exeOjo411pyTk4OcnBxD7dU11UWn06G4uNjkfaoVFRUBqDrpICQkxGjZiRMnAABardZofScnJwwfPhzDhw/HDz/8gI0bN2L9+vUYPHiwWX2ILEWpVEKhUJi0N+nwqd61oFQqYWdnV2OfzMxMKJVKMct6LJgzr6WlpQAADw8P+Pn5AQDmz5+PY8eOoV+/foa28+fPA6jaTVbdFhYWhh9++AFSqRTdunUDULUVsnz5ctjZ2WHcuHFo2bIl2rZti88//xxJSUmYNm2a4bjP0aNHoVarjd67Y8eO2LhxIw4cOICJEyeahMrt27fRqlUro9rvrak2dnZ2kMvldfbz8/PDyZMnsWjRIri7uwOo+kfUkSNH0Lp1a/j6+qJbt24oKChAixYtjNatrKzExo0boVAo4OfnV68+VIW/BxqeTqdDZmZmrbt4m3T4VO9qs7Ozq/XqeIlEwivnLcCcea3+ctra2hrW6dmzJ3r27HnfftHR0UhOTsbLL7+MF198ES4uLti/fz/OnDmD+fPnG36Bu7m54R//+AfWrVuHl19+GcOGDUNeXh62bNkCpVKJ4uJiw5gymQzvv/8+5s6di+effx6jR49GmzZtkJeXhzNnzuDy5cuG631qqqmuOcnLyzM5BRwAHB0dMXnyZCxatAhTpkzBpEmTMGHCBMhkMnzzzTe4du0aVq5caXifpUuX4vbt2+jTpw88PDyQn5+PxMRE2NvbY9iwYfXuQ1X4e8Byajvk0aTDh5q+Dh06IDExEatWrcLmzZtRVlaGTp06YcWKFRg9erRR39mzZ6N58+ZISEjAhx9+iE6dOuGjjz7CwYMHcerUKaO+Q4cOxddff43PPvsMmzdvRnFxsWHLY+7cuQ9c79WrV7FmzRqTdjc3N0yePBkhISFISEjA2rVr8fnnn0Ov16Nr16747LPPEBYWZtjlNmrUKOzYsQPbt283bOEEBQXhlVdeMZxUUZ8+RNYiEUQ8B1Ov12P16tXYsWMHSktLERwcjKVLl8LT07PG/mVlZVi9ejX279+PwsJCuLq6YvHixQgLC6vX+1XvH/fz86v1XzXVy6lhcV4tg/NqGZzXhne/37+ibvnEx8dj7969SEhIgJubG5YvX46oqCjs3r3b5GwIQRAMp7pu3rwZ7dq1w/Xr1w1n/RAR0aNL1PBJTExEZGQkvL29AQDz5s1D3759kZaWhh49ehj1PXbsGFJSUnD48GG4uLgAgGH/PRERPdpECx+NRgO1Wm20aevk5AQvLy9kZGSYhE9ycjLatm2LuLg47N+/HzKZDAMHDsQbb7wBuVxu1ntnZmaaHPQqrGyGHJ09ygUnXEq7DC+7EjTjpUANqrZTiunhcF4tg/PasO53REe08Km+hsHJycmoXaFQGJbdKz8/H5cuXUK/fv1w6NAh5OfnY/bs2VixYgWWLl1q1nsrlUqjfY6asgrsPnsNlf83NwWVtlDYu2NQl9ZmfiqqDfehWwbn1TI4rw3vr9ek/ZVo93arvlhPo9EYtWs0mhov5JPL5bCxsUFMTAwcHBzg4eGBGTNmNMgt7a9rygzBU01dUPrQ4xIRUf2IFj4KhQKenp5GSajRaJCdnY2uXbua9K++YPDe3WUNdYscB1uberUREZFliHpX6/DwcGzYsAFZWVkoKSlBbGwsOnToYHIrEQAYMmQIWrVqhVWrVkGn0yEvLw/x8fF45plnHroOD2d7tHW2N7yWAOjRvsVDj0tERPUjavhERkZi+PDhiIiIQN++faFWqxEXFwepVIrU1FQEBQUZ7t8ll8vxxRdfQKVSoVevXhg7diyCg4Mxf/78h65DKpFgoLI1BnRuhXa2pRjp5w4vF95kkYhILKKeai2VShEdHY3o6GiTZaGhoUhPTzdq69KlC7766ivL1CKRwMulOTRXdWjZnLeXJyISEx8mR0REomP4EBGR6Bg+REQkOoYPERGJjuFDRESiY/gQEZHoGD5ERCQ6hg8REYmO4UNERKJj+BARkegYPkREJDqGDxERiY7hQ0REomP4EBGR6Bg+REQkOoYPERGJjuFDRESiY/gQEZHoGD5ERCQ6hg8REYmO4UNERKJj+BARkegYPkREJDqGDxERia6ZmG+m1+uxevVq7NixA6WlpQgODsbSpUvh6elZY38fHx/IZDLY2NgY2hITE+Hj4yNWyUREZAGibvnEx8dj7969SEhIQFJSEjw8PBAVFQW9Xl/rOuvXr0d6errhD4OHiOjRJ2r4JCYmIjIyEt7e3pDL5Zg3bx6ysrKQlpYmZhlERGRlooWPRqOBWq2Gn5+foc3JyQleXl7IyMiodb3o6Gj06tULzz33HLZt2yZGqUREZGGiHfMpKioCUBU491IoFIZlf/Wf//wHQUFBkEqlSE5ORkxMDCoqKhAREWHWe2dmZkIikdS6XKVSmTUe1Q/n1TI4r5bBeW1YgiDUuVy08HF0dARQtQV0L41GY1j2V3369DH8/emnn8bUqVPx3XffmR0+SqUSMpmsxmUqlcpoa4waBufVMjivlsF5bXharbbOQBdtt5tCoYCnp6dRMRqNBtnZ2ejatWu9xpBKpfdNUyIiavxEPeEgPDwcGzZsQFZWFkpKShAbG4sOHTogJCTEpO/vv/+Os2fPQqfToaKiAseOHcPGjRvx7LPPilkyERFZgKjX+URGRkKj0SAiIgKlpaUICQlBXFwcpFIpUlNTMWPGDOzbtw8eHh7Iy8tDbGwsrl+/DhsbG3h4eOD111/HhAkTxCyZiIgsQNTwkUqliI6ORnR0tMmy0NBQpKenG14PGjQIgwYNErM8IiISCW+vQ0REomP4EBGR6ETd7dbUCIKAK3dKcadEh1ZyO7Rv6VDn9URERFSF4fMQki7fwdmr//+6paC2TujT0cWKFRERPRq42+0BabQVRsEDAOm5hSjRVVqpIiKiRwfD5wFpy2u+E7e2ovY7dBMRURWGzwNq2dwWzvbGey1bOtjC2YF7MomI7ofh84BspBKM8HNDuxb2kNvZoH1LB4zwc4OUJxwQEd0X/5n+EJwdbDHS393aZRARPXK45UNERKJj+BARkegYPkREJDqGDxERiY7hQ0REomP4EBGR6Bg+REQkOl7nY2Vl5ZX44dxNZOeXQiFrhkE+rdG2hYO1yyIisihu+VjZ/t/zcC6vCCW6SuRptNiZfhVF2gprl0VEZFEMHyvSCwIu3yoxatNVCsjJL7VSRURE4mD4WJEEgIOtjUl7TW1ERE0Jw8eKJBIJwrq0Mmrr1Lo52rvwmA8RNW084cDK/Dyc0NrRDjn5pXCyt0UXVznvjE1ETR7DpxFwd7KHu5O9tcsgIhINd7sREZHoGD5ERCQ6UcNHr9dj5cqV6Nu3L4KCgjB9+nSo1er7rqdSqfDkk09i0qRJIlRJRESWJmr4xMfHY+/evUhISEBSUhI8PDwQFRUFvV5f6zparRZvvvkmevToIWKlRERkSaKGT2JiIiIjI+Ht7Q25XI558+YhKysLaWlpta6zatUq9O7dGyEhISJWSkREliRa+Gg0GqjVavj5+RnanJyc4OXlhYyMjBrXSUlJwc8//4w33nhDrDKJiEgEop1qXVRUBKAqcO6lUCgMy+5VXFyMRYsWYdmyZXBweLiLLjMzMyGp49oZlUr1UONTzTivlsF5tQzOa8MSBKHO5aKFj6OjI4CqLaB7aTQaw7J7rVixAmFhYQ1yrEepVEImk9W4TKVSGW2NUcPgvFoG59UyOK8NT6vV1hnoooWPQqGAp6cnVCoV/P39AVQFT3Z2Nrp27WrSPykpCYWFhdizZw8AoKysDBUVFejVqxd27NiBdu3aiVX6I6G8Ug91QRnsbKRo4yyrc0uPiMjaRL3DQXh4ODZs2IDevXvDzc0NsbGx6NChQ40nE2zduhWVlZWG1xs3bsTp06exZs0auLq6ill2o5dfosOm5FwUlJYDALq4yjE+1BM2UgYQETVOop7tFhkZieHDhyMiIgJ9+/aFWq1GXFwcpFIpUlNTERQUhKtXrwIAXF1d4e7ubvjj6OgIOzs7uLu7w8aGd32+1w8ZNw3BAwAXbhYjPeeuFSsiIqqbqFs+UqkU0dHRiI6ONlkWGhqK9PT0Wtd99dVXLVnaI+1OcblpW4nOCpUQEdUPb6/TBHi2ML0pKR/FTUSNGcOnCRjS1RWdWjcHAEgkQL9OLujqbnoGIRFRY8FHKjQB9rY2mNirHUp1lbCRSmDXjP+mIKLGjeHThDjY8UQMIno08J/IREQkOoYPERGJjuFDRESiY/gQEZHoGD5ERCQ6hg8REYmO4UNERKJj+BARkegYPkREJDqzwufYsWNIS0szvN62bRvGjBmDhQsX1vgobCIiopqYFT6xsbHIz88HAGRlZWHp0qXw8/ODSqXChx9+aJECiYio6THr3m7Z2dlQKpUAgB9++AF9+vTBkiVLkJ6ejtdee80iBRIRUdNj9jEfiaTq0cwpKSno168fAMDNzQ0FBQUNWhgRETVdZoWPj48PtmzZgpSUFCQnJ+Opp54CAFy7dg0uLi4WKZCIiJoes8InOjoa33zzDSZPnozRo0ejc+fOAICff/4Z/v7+FimQiIiaHrOO+YSGhuL48eMoLi6Gk5OToX3cuHFwcOBjmx9lgiDgp/O3cOTCLVTqgR4dWmCEvztspBJrl0ZETZDZD5OzsbExBI8gCLh48SLatGkDR0c+tvlRlp5zFwf/uGF4fezSHTjZN8NAH1crVkVETZVZu91WrFiB7du3A6gKnilTpmDkyJEICwtDenq6RQokcVy8UWzadtO0jYioIZgVPgcOHECXLl0AAEePHsX58+exdetWjB49GitXrrRIgSQOJwfTjWAne1srVEJEjwOzdrvdunUL7u7uAKrCZ9iwYejevTucnZ0xduxYixRI4ujfuRVUVwtxQ6MDADjZN8OQrtzlRkSWYVb4ODs74+bNm3B3d0dycjJeeeUVAFW74CorKy1SIIlDLmuGOQM74VyeBpV6wMfNEc3tbKxdFhE1UWaFT//+/fH222+ja9euyM3NNVznc/HiRXh6et53fb1ej9WrV2PHjh0oLS1FcHAwli5dWuO6arUa0dHRyMrKQnl5OVxcXPDcc89h5syZhgtdqWHZNZMiwNPZ2mUQ0WPArGM+b731FkJDQ3H37l2sW7fOcNabSqXC8OHD77t+fHw89u7di4SEBCQlJcHDwwNRUVHQ6/UmfVu0aIEPPvgAx48fx6+//oqNGzdi79692LJlizklExFRI2TWlo+joyMWL15s0j537tx6rZ+YmIjIyEh4e3sDAObNm4e+ffsiLS0NPXr0MOorl8vRqVMnozapVIqsrCxzSiYiokbI7Ot8KioqsG/fPly8eBEAoFQqMXz4cDRrVvdQGo0GarUafn5+hjYnJyd4eXkhIyPDJHyqRUREQKVSQavVwt3dHRMmTDC3ZCIiamTMvqt1ZGQk8vLy0LFjRwDApk2b8PHHHyM+Ph7t2rWrdd3q5/3ce2cEAFAoFHU+C2jLli2orKzEb7/9hl9++QWtWrUyp2QAQGZmZp3HiVQqldlj0v1xXi2D82oZnNeGJQhCncvNCp9ly5bB3d0dX3/9tSEEbt26hblz52LZsmWIi4urdd3qOyBoNBqjdo1Gc9+7I9jY2CA4OBhpaWl47733sHr1anPKhlKphEwmq3GZSqUy2hqjhsF5tQzOq2VwXhueVqutM9DNOuHg5MmTWLhwodHWR+vWrbFgwQKcPHmyznUVCgU8PT2NitFoNMjOzkbXrl3r9f4VFRU85kNE1AQ88PN8jAaR1m+Y8PBwbNiwAVlZWSgpKUFsbCw6dOiAkJAQk77Hjx9HWloatFotKioqkJycjE2bNiEsLMzckomIqJExa7dbjx498OGHH2L16tVwdq66HqSgoACxsbEIDQ297/qRkZHQaDSIiIhAaWkpQkJCEBcXB6lUitTUVMyYMQP79u2Dh4cHSkpKsHz5cuTk5EAqlcLNzQ1TpkzBjBkzHuyTEhFRoyER7ndU6B5ZWVmYNm0aCgoKDKdBX7p0CS1btsQXX3yBDh06WKrOB1K9z9HPz4/HfETGebUMzqtlcF4b3v1+/5q15dOxY0ccOHAA3333HS5dugSgaldaUFAQZs6cif379zdM1URE1KSZfZ2PTCYzuYnouXPneCIAERHVm9knHBARET0shg8REYmO4UNERKKr1zGfadOm1bm8pKSkQYohIqLHQ73Cx83N7b59qu/1RkREdD/1Cp9//etflq6Dmoj0nAJ8k34NhaWVCLh7BRE928LBlk9EJSJjZp9qTVSbqwWl2HDsCvT/d9lyWnYBpBLgpb5e1i2MiBodnnBADeb8jSJD8FTLuK6puTMRPdYYPtRgnO1tTdqcamgjImL4UIPp3tYZvm7//9lMtlIJng/ysGJFRNRY8ZgPNRgbqQSzBnhDdbUQ5y9fwcAgH7gqar6hKxE93hg+1KBspBJ0b+sMmwIpg4eIasXdbkREJDqGDxERiY7hQ0REomP4EBGR6Bg+REQkOoYPERGJjuFDRESiY/gQEZHoGD5ERCQ6hg8REYmO4UNERKITNXz0ej1WrlyJvn37IigoCNOnT4dara6x7+nTp/Hyyy+jb9++CA4OxnPPPYfvv/9ezHKJiMhCRA2f+Ph47N27FwkJCUhKSoKHhweioqKg1+tN+t69exd///vfsXfvXqSmpiIqKgrR0dE4c+aMmCUTEZEFiBo+iYmJiIyMhLe3N+RyOebNm4esrCykpaWZ9A0LC8Po0aPh4uICqVSKZ555Bl26dKmxLzUtBSXl+Pzon1i69xw2JeegVFdp7ZKIqIGJ9kgFjUYDtVoNPz8/Q5uTkxO8vLyQkZGBHj161Ll+Xl4eLl++DF9fX7PfOzMzExKJpNblKpXK7DHp/h5kXiv1Ar78oxy3y6peX7pVgotXb2Gckk9Ercbvq2VwXhuWIAh1LhctfIqKigBUBc69FAqFYVltiouL8eqrr2LgwIHo06eP2e+tVCohk9X8bBmVSmUUiNQwHnReL94owu1fM43arhQKaNfJB84ODCB+Xy2D89rwtFptnYEu2m43R8eqxytrNBqjdo1GY1hWE41Gg8jISLi6umLFihUWrZGsz9bG9CspAdBMWvuWKxE9ekQLH4VCAU9PT6Mk1Gg0yM7ORteuXWtcJz8/H1OmTEGbNm2wZs0a2NnZiVUuWUl7FwcEeBpvHQ/ybQ25jA/dJWpKRP2JDg8Px4YNG9C7d2+4ubkhNjYWHTp0QEhIiEnfmzdv4qWXXoK/vz8++OADSKW8JOlxIJFI8Nogb/x0/hauF5ahQys5nursYu2yiKiBiRo+kZGR0Gg0iIiIQGlpKUJCQhAXFwepVIrU1FTMmDED+/btg4eHB7Zu3YoLFy4gNzcXBw4cMIwxcuRILF26VMyySWTNbKQY2u0Ja5dBRBYkavhIpVJER0cjOjraZFloaCjS09MNr2fPno3Zs2eLWR4REYmE+7KIiEh0DB8iIhIdw4eIiETH8CEiItExfIiISHQMHyIiEh3Dh4iIRMd7llCTdUOjxeWbxXBVyNDJVW7tcojoHgwfapKSL9/B6h8voUJfdVv3UQHumNynvZWrIqJq3O1GTY5eEPDpkSxD8ADAd2eu48/bJVasiojuxfChJkdbrkeR1vTpp7c0WitUQ0Q1YfhQk2NvK0WHVs2N2uxspPDmcR+iRoPhQ02ORCJBzJDO8G5dFUAtm9siZmhnuMj5PCiixoInHFCT5O5sjw/H+EFXoYetjQQSCZ+EStSYMHyoSbNrxo17osaI4UNUC70gYPdv13H80m3IZc0wIdQTPu4Ka5dF1CQwfIhqsT3tKv5zItvw+nTOXXwyIQCeLRysWBVR08B9EkS1+PHcTaPX2go9ki7esVI1RE0Lw4eoFrY2picp8BgSUcPgTxJRLcaGeBq9bu1oh4E+ra1UDVHTwmM+RLUYoGyNFg62OH75DhxlNhjh744WDrbWLouoSWD4ENUhsJ0zAts5W7sMoiaHu92IiEh0DB8iIhKdqOGj1+uxcuVK9O3bF0FBQZg+fTrUanWNfcvKyjBnzhwMHToUvr6+WLdunZilEhGRBYkaPvHx8di7dy8SEhKQlJQEDw8PREVFQa/Xm/SVSCQIDg7G0qVLERAQIGaZRERkYaKGT2JiIiIjI+Ht7Q25XI558+YhKysLaWlpJn1lMhmmTp2K3r17QyaTiVkmERFZmGjho9FooFar4efnZ2hzcnKCl5cXMjIyxCqDiIgaAdFOtS4qKgJQFTj3UigUhmWWkpmZWect9VUqlUXf/3HFebUMzqtlcF4bliAIdS4XLXwcHR0BVG0B3Uuj0RiWWYpSqax1151KpTLaGqOGwXm1DM6rZXBeG55Wq60z0EXb7aZQKODp6WlUjEajQXZ2Nrp27SpWGURWIQjCff8lSPQ4EfUOB+Hh4diwYQN69+4NNzc3xMbGokOHDggJCamxv06ngyAI0Ov1qKiogFarhUQigZ0dH4dMjwa9IOCzI39i1+mrEARgdGAbRIV1hJRPVqXHnKhnu0VGRmL48OGIiIhA3759oVarERcXB6lUitTUVAQFBeHq1auG/sOGDUNAQABSU1Px6aefIiAgANOnTxezZKKHsvv0NXydkovScj3KKvRITFXj2/Rr1i6LyOpE3fKRSqWIjo5GdHS0ybLQ0FCkp6cbtf30009ilUZkEb9mF5i25RRgTLCH+MUQNSK8vQ6RBbkqTE90cXXkbmMihg+RBb3Yqx08W9gbXns422Nir/ZWrIioceAjFYgsqJXcDhsmB+PUn/kAgJ4dWqC5HX/siPhTQGRhze1sMEDJJ6AS3Yu73YiISHQMHyIiEh3Dh+gRUFGpx7ELN3EipwQ3CsusXQ7RQ+MxH6JGTlehx9yv05B2peqkha/PHsPaF0Pg59nCuoURPQRu+RA1ct//fs0QPABQoqvE2h8yrVgR0cNj+BA1cjc1WpO2W0WmbUSPEoYPUSMX2sGlXm31oS2vRF5BCSr1vMM2WReP+RA1cv5tW2DxiCfxvz9fQGGpDgN83fHaEB+zx/n+TA6W7foVpboKtGnRHB++2AfKNi0avmCiemD4ED0CRgR6YkSgJ86ePQt/f3+z179eUIIlO1JQ8X9bPNcKSvDm18nYMfeZOp/yS2Qp3O1G9Ah50KC4mHfXEDzVcu8Uo6is/IHGq9TrH2g9omrc8iF6DLRzMX1UfUu5DHKZrVnjZN+8i3c2H0FG7m20ba3A2+OfQmBHt4Yqkx4j3PIhegx4uSow+xk/w2sHu2Z474UekErrvyWl1wuYt/EnZOTeBgDk3tIg5osfUVjyYGfeVVTq+Wjxxxi3fIgeE5P6++Bvfm1xraAEndyc4Nzc9FlDdbmtKcWfN+4atWlKdbhw9Q5COrep9zh3i8uwZNP3OPHHFSiayzDnuacwonc3s2oBgD/+vIp9x8/CRirF6KcD4e3havYYFZWV+DXjMs5lZqN9R284yZubPQYA3LhdgJt3CtCxrTuaO9jff4Ua/JaRiQtZ2fBu3xbBfr4PNIamqAjnLlxGK5cW8PZ6sEd3HD6ahH0Hvoe9TIbwsWPwZNcHq+V+GD5Ej5E2LeVo01L+QOsqmttBZmsDbXmlUburs3njfbj1Zxz7/U8AVUH0/uZD6OTRGl3bP1HvMdIzszHro82oqKw69rT7aDq+WDQVnTzrP4ZWV47XY79AWsZlAMCWH9Pwv4tehrenebsRN+78Lz5N3ANBEOCskGPlmzPhr/Q2b4xt3+F/N20zvJ46diRmTRlv1hiqjPN4bdFSFGqKAADjRz+L6FkzzDpOeOinw1j4zhLD6x8PH8Gm9XHo3Mm8z1Mf3O1GRPVib9sMMc/1hvSeX2ZTBwegvauTWeOkXcg1ei0IwOmLarPG2PpjiiF4AKBUW46dh381a4w9v6QaggcA7twtwrqv95s1RuafuYj7+jvD7sO7mmK8t+5Ls8a4qynCpwnbjdr+s30Prt+8bdY4H6z8xBA8ALB11z78+pvKrDF27v7O6LVOp8Oe/QfMGqO+uOVDRPU2qmcX+Hu5IlN9B+1aO6Fbe/OfU+TWQoF8TalR2xMtTU+IqIuuvKJebXW5frvApC2vhra6/Jl7zaQt59oNVFRWopmNTb3GKCjUQF/DRb/5dwvh7tqq3rXkqGuo5eo1hATW/9R8icR0e0Qqtcw2Crd8iMgsHd1a4Jlg7wcKHgB444Wn0fyes+z6+3fEgO6dzBpjRL/uRq+lEgn+3jfArDGCfDuatAX6mLbVpbNXW5PdWp3ae9Q7eADA0/0JtGtjvKvviVYt4d3e06xauvl2MXotkUjQtUtns8YYN2a00WsHe3uMena4WWPUl0RowqebaLVaqFQq+Pn5QSar+eBq9XJqWJxXy2gq83rrbjFOX1KjhdwBwV3amnXWXbVDqRnYfSQdNlIpxv+tB/r4mRdgALBp72Fs+PZHlGl1GNjDD+/8Yxya25t3IsbOg0ewcuM2lFdUoo2rCz5aOBOdvcwLjivqa/jnmvW4kJWNju08sXhOJDp3aGfWGFev5yHmnWW4cPlP2NnZYW7UNLwwyvzgSD6Vgn0Hf4C9nR3Gv/D8Ax/vud/vX4ZPE/lhbmw4r5bBeW14er0eZ86qENjdvC2nexWVlCL/rgZtXFuhWbP6b/U0NEEQcKfgLhzlzSGzs7NaHcD9f//ymA8RPdakUima2TzcEQjH5g5wbO7QQBU9OIlEglYtW1i7jHrhMR8iIhKdqOGj1+uxcuVK9O3bF0FBQZg+fTrU6tpPsfzjjz8QHh6O7t27Y8CAAdi0aZOI1RIRkaWIGj7x8fHYu3cvEhISkJSUBA8PD0RFRUFfw00Ki4qKEBkZiaeeegqnTp3C6tWr8fHHH+PAAcucc05EROIRNXwSExMRGRkJb29vyOVyzJs3D1lZWUhLSzPp+/3330MqlWLmzJmQyWQIDAzE2LFjsWXLFjFLJiIiCxDthAONRgO1Wm10po6TkxO8vLyQkZGBHj16GPU/d+4cunXrZnSBk5+fH7ZvN74SuC7VJ/LpdLo6+2i1fCRxQ+O8Wgbn1TI4rw2v+vdubSdUixY+RUVVt31wcjK+FYdCoTAs+2t/hUJh1Obk5FRj39qUl1c9qyQzM7POfiqVebegoPrhvFoG59UyOK+WUV5eDnt705utihY+jo5Vt8/QaDRG7RqNxrDsr/1v3za+t1FhYWGNfWsjl8uhVCpha2vLpzUSEYlIEASUl5dDLq/5xrOihY9CoYCnpydUKpXhMcAajQbZ2dno2rWrSX9fX1/897//hV6vN+x6+/333+HrW//be0ulUpOtJyIiEkdNWzzVRD3hIDw8HBs2bEBWVhZKSkoQGxuLDh06ICQkxKTv0KFDUVlZibi4OOh0Opw5cwbbt2/HhAkTxCyZiIgsQNTb6+j1eqxatQo7duxAaWkpQkJCsGTJErRt2xapqamYMWMG9u3bBw8PDwBV1/ksWbIEGRkZaNmyJaZPn47JkyeLVS4REVlIk763GxERNU68vQ4REYmO4UNERKJj+BARkegYPkREJDqGDxERie6xDJ99+/YhIiICwcHB8PHxsXY5Tc6pU6cQERGBoKAg9OzZE6+88oq1S3qk1PX9LCsrw5w5czB06FD4+vpi3bp1Vqry0XO/n/uysjIsX74cTz/9NAIDAzFkyBD88ssvVqj08fBYPsnUyckJERERKCsrw1tvvWXtcpqUlJQUvPLKK3j33XcxdOhQSKVSnDt3ztplPVLq+n5KJBIEBwcjIiICK1eutFKFj6a65lUQBMyaNQsAsHnzZrRr1w7Xr19HRUWFNUp9LDyW4dO/f38AwMmTJ61cSdPz0UcfYdy4cRg1apShLSAgwIoVPXrq+n7KZDJMnTrV8Heqv7rm9dixY0hJScHhw4fh4uICAHB3dxe1vsfNY7nbjSyjpKQEv/32GwDg+eefR69evTB+/HicOHHCypUR1S05ORlt27ZFXFwc+vXrh0GDBuGf//wniouLrV1ak8XwoQZTWFgIvV6PPXv24P3330dSUhLGjBmDqKgo5OTkWLs8olrl5+fj0qVLAIBDhw4hISEB6enpWLFihZUra7oYPtRgqm+dPmbMGHTr1g22trYYN24c2rZti6NHj1q5OqLayeVy2NjYICYmBg4ODvDw8MCMGTNw6NAha5fWZDF8qMEoFAq0a9fOpJ3PUqLGrlu3bgCMv6v83lrWYxk+lZWV0Gq1hiedarVaaLVa6PV6K1f26HvxxRexc+dOnD9/HpWVldi5cyfUajWefvppa5f2yLjf91On0xleV1RUQKvV1vmoeKpS17wOGTIErVq1wqpVq6DT6ZCXl4f4+Hg888wzVq666Xos72r9zTff4M033zRp37RpE3r16mWFipoOQRDwySefIDExESUlJejSpQuio6PRs2dPa5f2yLjf93PQoEFQq9VGy3r27ImvvvpKrBIfSfeb1wsXLmDp0qVQqVRQKBQYNmwY5s6dCwcHBytU2/Q9luFDRETW9VjudiMiIuti+BARkegYPkREJDqGDxERiY7hQ0REomP4EBGR6Bg+RHXIzc2Fj48PUlNTrV2KkaKiIsyaNQshISHw8fFBbm6utUuq06RJk/j4EjLC8KFGa+HChfDx8cGHH35o1H79+nX4+Pg81o/E2LJlC06fPo0tW7YgKSkJbdq0sXZJRGZh+FCjJpPJ8NVXX5lc0d8UVN/m5UFcuXIFnTt3ho+PD1xdXWFjY9OAlRFZHsOHGrWgoCD4+vrW+dTO2naNDRkyxOgx0z4+Pvjqq6/w+uuvIzAwEAMGDMCBAweg0WgQHR2NoKAgDB48GAcPHjR5D7VajSlTpiAgIACDBw/Gvn37jJbfunULCxcuRO/evREUFITw8HCkpKQYlp88eRI+Pj44fPgwJkyYAH9/f2zfvr3Gz1NeXo5///vf6N+/P/z8/PD3v/8de/bsMSwfNGgQduzYgeTkZPj4+GDSpEm1zs2VK1fw6quvIjQ0FD169MC0adNw/vx5w/JvvvkG3bp1w/Hjx/Hss8/C398fY8eORUZGhtE4v/zyC55//nn4+fmhT58+eO+991BSUmLUZ//+/Xj++efh7++PXr16ITIyEnfv3jXq88knn6Bfv37o2bMn5s+fb/S8nAsXLmD69OkIDQ1FYGAghg8fjl27dtX62ejRxvChRk0ikWDBggXYt28fzp49+9DjffrppwgLC8Pu3bsxYMAAzJ8/H3PnzkW/fv2wa9cuDBgwAAsWLEB+fr7RerGxsRgzZgx27dqFESNGICYmBn/88QcAoKysDJMnT0ZxcTHWr1+PXbt2ISwsDC+99JLhGTHVli9fjhkzZmD//v0YNGhQjTWuXLkS27dvx6JFi7Bnzx6MGjUK8+bNMzyUb8eOHRg+fDhCQ0ORlJRkFLD3unXrFiIiIuDi4oLNmzdj69at6NixIyZPnow7d+4Y+un1esTGxuLdd9/F9u3b4eLigpdffhllZWUAgHPnzuGVV15BaGgodu/ejeXLl+Pw4cN49913DWPs3LkT8+bNw+DBg/Htt9/iyy+/RP/+/VFZWWnoc/DgQdy9exebNm3CypUrcfjwYaxfv96w/I033kCLFi2QmJiIPXv2YOHChXB2dr7v/1N6RAlEjdSCBQuEKVOmCIIgCDNnzhQmTpwoCIIgXLt2TVAqlUJycrIgCIKQk5MjKJVKISUlxWj9v/3tb8LatWsNr5VKpfD+++8bXt++fVtQKpXC0qVLDW0FBQWCUqkUfvrpJ6OxV61aZTT2+PHjhZiYGEEQBGHnzp1C//79hfLycqM+kyZNMrxfcnKyoFQqhW+//bbOz1xSUiI8+eSTQkJCglH7zJkzhUmTJtU4N7VZu3atMHbsWKM2vV4vDB48WNi4caOhdqVSKRw/ftxoDgIDA4Vt27YJgiAIMTExwpgxY4zG+eGHHwQfHx8hNzdXEARBCAsLE5YsWVJrLRMnThRGjhxp1PbOO+8I48aNM7wODg4Wdu7cWednoqajmbXDj6g+YmJiMGLECPz444948sknH3gcX19fw99dXFxgY2MDHx8fQ5uzszNsbW1x+/Zto/WCgoJMXicnJwMAzp49i1u3bqFHjx5GfXQ6Hezt7Y3aAgIC6qzvypUrKC8vNxmrR48e+Pzzz+/z6YydPXsWv//+u0ntZWVluHLlilFbYGCg4e/Ozs7w9vbGxYsXAQAXL15E7969jfr37NkTgiDg4sWLsLe3x7Vr19CvX78667l37gHgiSeeQFJSkuH1tGnTsHjxYnz77bfo2bMnBg0a9FD/r6lxY/jQI6Fjx44YP348/v3vfxvtqgEAqbTmvccVFRUmbc2amX7l/9omkUggmHGzd71ej06dOuHjjz82WfbX8GnevHm9x31Yer0evXv3xjvvvGOyTKFQiFZHNVtbW6PXf53nWbNmYdSoUThy5AhOnjyJzz77DNOnT8fcuXPFLpVEwGM+9MiYPXs2bty4gW3bthm1u7i4AABu3LhhaLt9+zby8vIa7L1Pnz5t9Do9PR2dOnUCAPj5+SEnJweOjo7w8vIy+uPm5mbW+3h5ecHOzs7oZAUASElJQZcuXcway8/PDxcvXoS7u7tJXdVzVtPnKywsxOXLl9G5c2cAQOfOnU3qOXXqFCQSCbp06YJWrVrB3d0dx44dM6u+mrRr1w4vvvgi1q5dizlz5iAxMfGhx6TGieFDj4zqA+FffvmlUbu9vT2Cg4MRHx+Pc+fOQaVSYf78+bCzs2uw996xYwf27NmDrKwsrFmzBqdPn8ZLL70EABg1ahTatm2Ll19+GUlJScjNzcVvv/2Gzz77DIcOHTLrfRwcHDBp0iSsXbsW//3vf5GVlYVPP/0UP/74I6Kioswaa+LEiaisrMTMmTORmpqK3NxcpKamYtWqVfj1118N/SQSCWJjY5GSkoLz589j/vz5kMvlGDFiBABg+vTp+OOPP7Bs2TJcunQJR44cwfvvv4+RI0fCw8MDQNU/DLZu3YpPPvkEly5dwoULF5CQkGB0YkNdiouLsWTJEpw4cQI5OTn4448/cPToUUPAU9PD3W70SJk6dSq+/vprXLt2zah92bJlePvttxEeHo4nnngCMTExyM7ObrD3jY6OxrZt27Bo0SK4uroiNjbWcDyi+lqk1atX480330R+fj5atmyJgIAA9O/f3+z3mjt3LqRSKZYtW4b8/Hy0b98esbGx6NOnj1njtG7dGlu3bsXKlSsxe/ZsFBUVwdXVFSEhIXB1dTX0k0qleOONN/DOO+8gJycHvr6++OyzzwxP8PT19UVcXBzWrFmDLVu2wNHREc888wwWLFhgGGPs2LGQyWSIj49HXFwc5HI5unfvjlGjRtWr1mbNmqGwsBBvvfUWbt68CUdHR/Tq1cvoPahp4ZNMiR5j33zzDRYvXmw4bZxILNztRkREomP4EBGR6LjbjYiIRMctHyIiEh3Dh4iIRMfwISIi0TF8iIhIdAwfIiISHcOHiIhE9/8AsD1CjeMgpNEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = sns.factorplot(x='epoch', y=\"Loss\", linestyles=[\"-\", \"--\",\"-\", \"--\"], markers=['.','x','v','+'], \n",
    "                   palette=\"Blues_d\", legend_out = False, data=df_his, size=4, aspect=1.5)\n",
    "type(g)\n",
    "\n",
    "g.fig.suptitle('Model Loss')\n",
    "\n",
    "g.axes[0,0].set_xlabel('Number of epochs')\n",
    "plt.xticks([0, 5, 10, 15, 20]) \n",
    "plt.grid(True, which=\"both\",ls=\"-\",c='#D3D3D3') \n",
    "sns.despine(bottom = False, left = False, right=False, top=False)\n",
    "\n",
    "\n",
    "\n",
    "new_labels = ['Stego Classifier']\n",
    "#for t, l in zip(g._legend.texts, new_labels):\n",
    "#    t.set_text(l)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Figure' object has no attribute 'set_title'",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_10414/1820363719.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_title\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Plot\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfontsize\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m20\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      2\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_xlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Number of epoch\"\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#g.set_ylabel(\"loss\", fontsize = 20)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m#g.set_title(\"Plot\", fontsize = 20)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Figure' object has no attribute 'set_title'"
     ],
     "output_type": "error"
    }
   ],
   "source": [
    "g.fig.set_title(\"Plot\", fontsize = 20)\n",
    "g.set_xlabel(\"Number of epoch\")\n",
    "#g.set_ylabel(\"loss\", fontsize = 20)\n",
    "#g.set_title(\"Plot\", fontsize = 20)\n",
    "\n",
    "#g.fig.get_axes()[0].set_yscale('log')\n",
    "plt.xticks([0, 5, 10, 15, 20]) \n",
    "plt.grid(True, which=\"both\",ls=\"-\",c='#D3D3D3') \n",
    "sns.despine(bottom = False, left = False, right=False, top=False)\n",
    "g.set_xlabels(\"Number of epochs\")\n",
    "\n",
    "#g._legend.set_title(\"\")\n",
    "new_labels = ['Stego Classifier']\n",
    "#for t, l in zip(g._legend.texts, new_labels):\n",
    "#    t.set_text(l)\n",
    "\n",
    "plt.tight_layout() \n",
    "\n",
    "plt.savefig('output/training_loss.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#reload best model\n",
    "detector.load_weights(model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#legit images 2000\n",
      "#stego images [1234, 1247, 1167, 1188, 1164]\n",
      "data shape:  (8000, 512, 512, 3)\n",
      "done\n",
      "#test shape, neg, pos:  (8000, 512, 512, 3) 2000 6000\n",
      "test set unseen ready\n"
     ]
    }
   ],
   "source": [
    "#loading test set plain\n",
    "test, num_test_legit, num_test_stego_for_class  = load_data(data_folder, \"test_plain\", legit_folder, stego_folders)\n",
    "num_test_stego = np.sum(num_test_stego_for_class)\n",
    "print(\"#test shape, neg, pos: \", test.shape, num_test_legit, num_test_stego)\n",
    "\n",
    "#lsb extraction\n",
    "test = extract_1_lsb_features(test)\n",
    "\n",
    "#create target\n",
    "\n",
    "y_test = create_target(num_test_legit, num_test_stego)\n",
    "print(\"test set unseen ready\")\n",
    "\n",
    "\n",
    "#print(\"#num examples for class:\")\n",
    "#(unique, counts) = np.unique(y_test, return_counts=True)\n",
    "#frequencies = np.asarray((unique, counts)).T\n",
    "#print(frequencies)\n",
    "#print(\"Apply OHE\")\n",
    "#ohe_y_test = ohe_processer.transform(np.reshape(y_test,(-1,1))).toarray()\n",
    "#print(\"test set ready\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, ..., 1, 1, 1], dtype=int8)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250/250 [==============================] - 42s 160ms/step\n",
      "acc;prec;rec;f1;auc;auc-pr\n",
      "0.99175;0.9994949494949495;0.9895;0.9944723618090452;0.9998479166666667;0.9999435265947455\n"
     ]
    }
   ],
   "source": [
    "y_pred_score = detector.predict(test)\n",
    "\n",
    "y_pred_label = np.around(y_pred_score, 0)\n",
    "\n",
    "report_map = classification_report(y_test, y_pred_label, output_dict=True)\n",
    "\n",
    "acc_score = accuracy_score(y_test, y_pred_label)\n",
    "\n",
    "auc_score = roc_auc_score(y_test, y_pred_score)\n",
    "\n",
    "pr1, rec1, thr1 = precision_recall_curve(y_test, y_pred_score)\n",
    "\n",
    "auc_score_pr = auc(rec1, pr1)\n",
    "\n",
    "result = str(acc_score)+\";\"+str(report_map['1']['precision']) + \";\" + str(\n",
    "        report_map['1']['recall']) + \";\" + str(report_map['1']['f1-score']) + \";\" + str(\n",
    "        auc_score) + \";\" + str(auc_score_pr)\n",
    "\n",
    "print(\"acc;prec;rec;f1;auc;auc-pr\")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#legit images 2000\n",
      "#stego images [1234, 1247, 1167, 1188, 1164]\n",
      "data shape:  (8000, 512, 512, 3)\n",
      "done\n",
      "#test shape, neg, pos:  (8000, 512, 512, 3) 2000 6000\n",
      "test set unseen ready\n"
     ]
    }
   ],
   "source": [
    "#loading test set b64\n",
    "test, num_test_legit, num_test_stego_for_class  = load_data(data_folder, \"test_b64\", legit_folder, stego_folders)\n",
    "\n",
    "num_test_stego = np.sum(num_test_stego_for_class)\n",
    "print(\"#test shape, neg, pos: \", test.shape, num_test_legit, num_test_stego)\n",
    "\n",
    "#lsb extraction\n",
    "test_b64 = extract_1_lsb_features(test)\n",
    "\n",
    "#create target\n",
    "\n",
    "y_test = create_target(num_test_legit, num_test_stego)\n",
    "print(\"test set unseen ready\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250/250 [==============================] - 55s 160ms/step\n",
      "acc;prec;rec;f1;auc;auc-pr\n",
      "0.9985;0.9994994994994995;0.9985;0.9989994997498749;0.9999379166666666;0.9999781130709715\n"
     ]
    }
   ],
   "source": [
    "y_pred_score = detector.predict(test_b64)\n",
    "\n",
    "y_pred_label = np.around(y_pred_score, 0)\n",
    "\n",
    "report_map = classification_report(y_test, y_pred_label, output_dict=True)\n",
    "\n",
    "acc_score = accuracy_score(y_test, y_pred_label)\n",
    "\n",
    "auc_score = roc_auc_score(y_test, y_pred_score)\n",
    "\n",
    "pr1, rec1, thr1 = precision_recall_curve(y_test, y_pred_score)\n",
    "\n",
    "auc_score_pr = auc(rec1, pr1)\n",
    "\n",
    "result = str(acc_score)+\";\"+str(report_map['1']['precision']) + \";\" + str(\n",
    "        report_map['1']['recall']) + \";\" + str(report_map['1']['f1-score']) + \";\" + str(\n",
    "        auc_score) + \";\" + str(auc_score_pr)\n",
    "\n",
    "print(\"acc;prec;rec;f1;auc;auc-pr\")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#legit images 2000\n",
      "#stego images [1234, 1247, 1167, 1188, 1164]\n",
      "data shape:  (8000, 512, 512, 3)\n",
      "done\n",
      "#test shape, neg, pos:  (8000, 512, 512, 3) 2000 6000\n",
      "test set unseen ready\n"
     ]
    }
   ],
   "source": [
    "#loading test set zip\n",
    "test, num_test_legit, num_test_stego_for_class  = load_data(data_folder, \"test_zip\", legit_folder, stego_folders)\n",
    "\n",
    "num_test_stego = np.sum(num_test_stego_for_class)\n",
    "print(\"#test shape, neg, pos: \", test.shape, num_test_legit, num_test_stego)\n",
    "\n",
    "#lsb extraction\n",
    "test_zip = extract_1_lsb_features(test)\n",
    "\n",
    "#create target\n",
    "\n",
    "y_test = create_target(num_test_legit, num_test_stego)\n",
    "print(\"test set unseen ready\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250/250 [==============================] - 59s 162ms/step\n",
      "acc;prec;rec;f1;auc;auc-pr\n",
      "0.999625;0.9995002498750625;1.0;0.9997500624843789;0.9999985;0.9999994993320644\n"
     ]
    }
   ],
   "source": [
    "y_pred_score = detector.predict(test_zip)\n",
    "\n",
    "y_pred_label = np.around(y_pred_score, 0)\n",
    "\n",
    "report_map = classification_report(y_test, y_pred_label, output_dict=True)\n",
    "\n",
    "acc_score = accuracy_score(y_test, y_pred_label)\n",
    "\n",
    "auc_score = roc_auc_score(y_test, y_pred_score)\n",
    "\n",
    "pr1, rec1, thr1 = precision_recall_curve(y_test, y_pred_score)\n",
    "\n",
    "auc_score_pr = auc(rec1, pr1)\n",
    "\n",
    "result = str(acc_score)+\";\"+str(report_map['1']['precision']) + \";\" + str(\n",
    "        report_map['1']['recall']) + \";\" + str(report_map['1']['f1-score']) + \";\" + str(\n",
    "        auc_score) + \";\" + str(auc_score_pr)\n",
    "\n",
    "print(\"acc;prec;rec;f1;auc;auc-pr\")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}