old/gray.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy\n",
    "import time\n",
    "import signal\n",
    "import binascii\n",
    "import threading\n",
    "import subprocess\n",
    "from PIL import Image\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "\n",
    "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers, models\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "from raw_features import ByteHistogram, ByteEntropyHistogram\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读取数据地址"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = \"../data_rec_mzpe\"\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = '0'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_black_path = []\n",
    "# for parent, dirnames, filenames in os.walk(os.path.join(data_dir, \"train\")):\n",
    "#     if \"black\" in parent:\n",
    "#         for filename in filenames:\n",
    "#             fp = os.path.join(parent, filename)\n",
    "#             train_black_path.append(os.path.abspath(fp))\n",
    "\n",
    "# train_white_path = []\n",
    "# for parent, dirnames, filenames in os.walk(os.path.join(data_dir, \"train\")):\n",
    "#     if \"white\" in parent:\n",
    "#         for filename in filenames:\n",
    "#             fp = os.path.join(parent, filename)\n",
    "#             train_white_path.append(os.path.abspath(fp))\n",
    "\n",
    "# test_path = []\n",
    "# for parent, dirnames, filenames in os.walk(os.path.join(data_dir, \"test\")):\n",
    "#     for filename in filenames:\n",
    "#         fp = os.path.join(parent, filename)\n",
    "#         test_path.append(os.path.abspath(fp))\n",
    "\n",
    "# real_path = []\n",
    "# for parent, dirnames, filenames in os.walk(os.path.join(data_dir, \"real\")):\n",
    "#     if \"1_data_real\" in parent:\n",
    "#         for filename in filenames:\n",
    "#             fp = os.path.join(parent, filename)\n",
    "#             real_path.append(os.path.abspath(fp))\n",
    "\n",
    "# with open(\"train_black_path.pkl\", 'wb') as f:\n",
    "#     pickle.dump(train_black_path, f)\n",
    "\n",
    "# with open(\"train_white_path.pkl\", 'wb') as f:\n",
    "#     pickle.dump(train_white_path, f)\n",
    "\n",
    "# with open(\"test_path.pkl\", 'wb') as f:\n",
    "#     pickle.dump(test_path, f)\n",
    "\n",
    "# with open(\"real_path.pkl\", 'wb') as f:\n",
    "#     pickle.dump(real_path, f)\n",
    "\n",
    "with open(\"train_black_path.pkl\", 'rb') as f:\n",
    "    train_black_path = pickle.load(f)\n",
    "\n",
    "with open(\"train_white_path.pkl\", 'rb') as f:\n",
    "    train_white_path = pickle.load(f)\n",
    "\n",
    "with open(\"test_path.pkl\", 'rb') as f:\n",
    "    test_path = pickle.load(f)\n",
    "\n",
    "with open(\"real_path.pkl\", 'rb') as f:\n",
    "    real_path = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "拷贝一份"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if not os.path.exists(\"gray\"):\n",
    "#     os.makedirs(\"gray/black\")\n",
    "#     os.makedirs(\"gray/white\")\n",
    "#     os.makedirs(\"gray/test\")\n",
    "#     os.makedirs(\"gray/real\")\n",
    "\n",
    "# for pt in train_black_path:\n",
    "#     os.system(\"cp {0} {1}\".format(pt, \"gray/black/\"))\n",
    "# for pt in train_white_path:\n",
    "#     os.system(\"cp {0} {1}\".format(pt, \"gray/white/\"))\n",
    "# for pt in test_path:\n",
    "#     os.system(\"cp {0} {1}\".format(pt, \"gray/test/\"))\n",
    "# for pt in real_path[6007:]:\n",
    "#     os.system(\"cp {0} {1}\".format(pt, \"gray/real/\"))\n",
    "\n",
    "train_black_path = [pt.replace(\"data_rec_mzpe/train/1_2000_\", \"jupyterlab/gray/\") for pt in train_black_path]\n",
    "train_white_path = [pt.replace(\"data_rec_mzpe/train/1_4000_\", \"jupyterlab/gray/\") for pt in train_white_path]\n",
    "test_path = [pt.replace(\"data_rec_mzpe/test/data\", \"jupyterlab/gray/test\") for pt in test_path]\n",
    "real_path = [pt.replace(\"data_rec_mzpe/real/1_data_real\", \"jupyterlab/gray/real\") for pt in real_path]\n",
    "real_path = [pt.replace(\"data_rec_mzpe/real/2_data_real\", \"jupyterlab/gray/real\") for pt in real_path]\n",
    "real_path = [pt.replace(\"data_rec_mzpe/real/3_data_real\", \"jupyterlab/gray/real\") for pt in real_path]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 提取灰度图信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty = threading.Semaphore(value=20)\n",
    "\n",
    "def getMatrixfrom_bin(filename, width):  #生成灰度图\n",
    "    with open(filename, 'rb') as f:\n",
    "        content = f.read()\n",
    "    hexst = binascii.hexlify(content)  #将二进制文件转换为十六进制字符串\n",
    "    fh = numpy.array(\n",
    "        [int(hexst[i:i + 2], 16) for i in range(0, len(hexst), 2)])  #按字节分割\n",
    "    rn = int(len(fh) / width)\n",
    "    fh = numpy.reshape(fh[:rn * width], (-1, width))  #根据设定的宽度生成矩阵\n",
    "    fh = numpy.uint8(fh)\n",
    "    return fh\n",
    "\n",
    "def generate_gray(fp):\n",
    "    filename = fp\n",
    "    try:\n",
    "        im = Image.fromarray(getMatrixfrom_bin(filename, 512))  #转换为图像\n",
    "        im = im.resize((512, 512))\n",
    "        PNG = filename + '.png'\n",
    "        im.save(PNG)\n",
    "    except Exception as e:\n",
    "        pass\n",
    "    os.remove(fp)\n",
    "\n",
    "    empty.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "gray: 100%|█████████████████████████████████| 3010/3010 [41:53<00:00,  1.20it/s]\n"
     ]
    }
   ],
   "source": [
    "# with tqdm(total=6000, ncols=80, desc=\"gray\") as pbar:\n",
    "#     for fp in train_black_path:\n",
    "#         empty.acquire()\n",
    "#         t = threading.Thread(target=generate_gray, args=(fp, ), daemon=True)\n",
    "#         t.start()\n",
    "#         pbar.update(1)\n",
    "#     for fp in train_white_path:\n",
    "#         empty.acquire()\n",
    "#         t = threading.Thread(target=generate_gray, args=(fp, ), daemon=True)\n",
    "#         t.start()\n",
    "#         pbar.update(1)\n",
    "\n",
    "# with tqdm(total=6000, ncols=80, desc=\"gray\") as pbar:\n",
    "#     for fp in test_path:\n",
    "#         empty.acquire()\n",
    "#         t = threading.Thread(target=generate_gray, args=(fp, ), daemon=True)\n",
    "#         t.start()\n",
    "#         pbar.update(1)\n",
    "\n",
    "with tqdm(total=len(real_path[6007:]), ncols=80, desc=\"gray\") as pbar:\n",
    "    for fp in real_path[6007:]:\n",
    "        empty.acquire()\n",
    "        t = threading.Thread(target=generate_gray, args=(fp, ), daemon=True)\n",
    "        t.start()\n",
    "        pbar.update(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读取直方图数据和打标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "gray: 100%|██████████████████████████████| 21017/21017 [01:09<00:00, 302.95it/s]\n"
     ]
    }
   ],
   "source": [
    "raw_data, raw_labels = [], []\n",
    "\n",
    "test_data_feature, real_data_feature = [], []\n",
    "\n",
    "with tqdm(total=6000*2 + len(real_path), ncols=80, desc=\"gray\") as pbar:\n",
    "    for fp in train_black_path:\n",
    "        image = Image.open(fp+'.png')\n",
    "        image_data = np.array(image)\n",
    "        raw_data.append(image_data)\n",
    "        raw_labels.append(1)\n",
    "        pbar.update(1)\n",
    "    for fp in train_white_path:\n",
    "        image = Image.open(fp+'.png')\n",
    "        image_data = np.array(image)\n",
    "        raw_data.append(image_data)\n",
    "        raw_labels.append(0)\n",
    "        pbar.update(1)\n",
    "    for fp in test_path:\n",
    "        image = Image.open(fp+'.png')\n",
    "        image_data = np.array(image)\n",
    "        test_data_feature.append(image_data)\n",
    "        pbar.update(1)\n",
    "    for fp in real_path:\n",
    "        image = Image.open(fp+'.png')\n",
    "        image_data = np.array(image)\n",
    "        real_data_feature.append(image_data)\n",
    "        pbar.update(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 超参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAIN_SIZE = 0.8\n",
    "VAL_SIZE = 0.1\n",
    "TEST_SIZE = 0.1\n",
    "SEED = 4396\n",
    "\n",
    "WIDTH, HEIGHT = 512, 512\n",
    "BATCH_SIZE = 32\n",
    "EPOCH = 300\n",
    "SHUFFLE = False\n",
    "CLASSES = 2\n",
    "\n",
    "LR = 1e-5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 打乱顺序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(SEED)\n",
    "tf.random.set_seed(SEED)\n",
    "\n",
    "img_data, labels = np.array(raw_data, dtype=np.float32), np.array(raw_labels, dtype=np.int32)\n",
    "\n",
    "index = list(range(len(labels)))\n",
    "np.random.shuffle(index)\n",
    "\n",
    "img_data = img_data[index]\n",
    "labels = labels[index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 划分数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_image, test_image, train_label, test_label = train_test_split(\n",
    "    img_data,\n",
    "    labels,\n",
    "    test_size=TEST_SIZE,\n",
    "    stratify=labels,\n",
    "    random_state=SEED)\n",
    "train_image, valid_image, train_label, valid_label = train_test_split(\n",
    "    train_image,\n",
    "    train_label,\n",
    "    test_size=VAL_SIZE,\n",
    "    stratify=train_label,\n",
    "    random_state=SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = tf.data.Dataset.from_tensor_slices((train_image, train_label)) \\\n",
    "                            .batch(BATCH_SIZE) \\\n",
    "                            .prefetch(buffer_size = tf.data.experimental.AUTOTUNE)\n",
    "\n",
    "valid_ds = tf.data.Dataset.from_tensor_slices((valid_image, valid_label)) \\\n",
    "                            .batch(BATCH_SIZE) \\\n",
    "                            .prefetch(buffer_size = tf.data.experimental.AUTOTUNE)\n",
    "\n",
    "test_ds = tf.data.Dataset.from_tensor_slices((test_image, test_label)) \\\n",
    "                            .batch(BATCH_SIZE) \\\n",
    "                            .prefetch(buffer_size = tf.data.experimental.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构建模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构建模型\n",
    "inputs = layers.Input(shape=(WIDTH, HEIGHT), dtype='float32')\n",
    "inputs_re = tf.reshape(inputs, (-1, WIDTH, HEIGHT, 1))\n",
    "Conv_1 = layers.Convolution2D(30, (3, 3),\n",
    "                              strides=2,\n",
    "                              padding='same',\n",
    "                              activation='relu')(inputs_re)\n",
    "Max_pool_1 = layers.MaxPooling2D((2, 2), strides=2)(Conv_1)\n",
    "Conv_2 = layers.Convolution2D(50, (3, 3),\n",
    "                              strides=2,\n",
    "                              padding='same',\n",
    "                              activation='relu')(Max_pool_1)\n",
    "Max_pool_2 = layers.MaxPooling2D((2, 2), strides=2)(Conv_2)\n",
    "Conv_3 = layers.Convolution2D(100, (3, 3),\n",
    "                              strides=2,\n",
    "                              padding='same',\n",
    "                              activation='relu')(Max_pool_2)\n",
    "Max_pool_3 = layers.MaxPooling2D((2, 2), strides=2)(Conv_3)\n",
    "Flat = layers.Flatten()(Max_pool_3)\n",
    "Dense_1 = layers.Dense(500, activation='tanh')(Flat)\n",
    "dropout = layers.Dropout(0.5)(Dense_1)\n",
    "outputs = layers.Dense(1, activation='sigmoid')(dropout)\n",
    "\n",
    "\n",
    "model = models.Model(inputs=inputs, outputs=outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自定义评估指标\n",
    "def score(y_true, y_pred):\n",
    "    y_true = tf.cast(tf.reshape(y_true, (-1,)), tf.int32)\n",
    "    y_pred = tf.cast(tf.math.round(tf.reshape(y_pred, (-1,))), tf.int32)\n",
    "\n",
    "    tp = tf.reduce_sum(tf.cast(tf.logical_and(tf.equal(y_true, 1), tf.equal(y_pred, 1)), dtype=tf.float32))\n",
    "    fn = tf.reduce_sum(tf.cast(tf.logical_and(tf.equal(y_true, 1), tf.equal(y_pred, 0)), dtype=tf.float32))\n",
    "    fp = tf.reduce_sum(tf.cast(tf.logical_and(tf.equal(y_true, 0), tf.equal(y_pred, 1)), dtype=tf.float32))\n",
    "    tn = tf.reduce_sum(tf.cast(tf.logical_and(tf.equal(y_true, 0), tf.equal(y_pred, 0)), dtype=tf.float32))\n",
    "\n",
    "    result = (tp/(tp+fn)) - 0.9*(fp/(fp+tn))\n",
    "    \n",
    "    return result\n",
    "\n",
    "model.compile(optimizer=tf.keras.optimizers.Nadam(LR),\n",
    "                loss='binary_crossentropy',\n",
    "                metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_2 (InputLayer)         [(None, 512, 512)]        0         \n",
      "_________________________________________________________________\n",
      "tf_op_layer_Reshape_1 (Tenso [(None, 512, 512, 1)]     0         \n",
      "_________________________________________________________________\n",
      "conv2d_3 (Conv2D)            (None, 256, 256, 30)      300       \n",
      "_________________________________________________________________\n",
      "max_pooling2d_3 (MaxPooling2 (None, 128, 128, 30)      0         \n",
      "_________________________________________________________________\n",
      "conv2d_4 (Conv2D)            (None, 64, 64, 50)        13550     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_4 (MaxPooling2 (None, 32, 32, 50)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_5 (Conv2D)            (None, 16, 16, 100)       45100     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_5 (MaxPooling2 (None, 8, 8, 100)         0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 6400)              0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 500)               3200500   \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 500)               0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 1)                 501       \n",
      "=================================================================\n",
      "Total params: 3,259,951\n",
      "Trainable params: 3,259,951\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/300\n",
      "152/152 [==============================] - 9s 56ms/step - loss: 0.2638 - accuracy: 0.9187 - val_loss: 0.1581 - val_accuracy: 0.9574 - lr: 1.0000e-05\n",
      "Epoch 2/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.2052 - accuracy: 0.9426 - val_loss: 0.1491 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 3/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.2020 - accuracy: 0.9467 - val_loss: 0.1443 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 4/300\n",
      "152/152 [==============================] - 8s 54ms/step - loss: 0.1973 - accuracy: 0.9453 - val_loss: 0.1392 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 5/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.1793 - accuracy: 0.9473 - val_loss: 0.1317 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 6/300\n",
      "152/152 [==============================] - 9s 59ms/step - loss: 0.1791 - accuracy: 0.9467 - val_loss: 0.1287 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 7/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.1794 - accuracy: 0.9484 - val_loss: 0.1276 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 8/300\n",
      "152/152 [==============================] - 8s 53ms/step - loss: 0.1693 - accuracy: 0.9479 - val_loss: 0.1227 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 9/300\n",
      "152/152 [==============================] - 9s 57ms/step - loss: 0.1706 - accuracy: 0.9506 - val_loss: 0.1225 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 10/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.1649 - accuracy: 0.9525 - val_loss: 0.1184 - val_accuracy: 0.9593 - lr: 1.0000e-05\n",
      "Epoch 11/300\n",
      "152/152 [==============================] - 8s 55ms/step - loss: 0.1611 - accuracy: 0.9514 - val_loss: 0.1225 - val_accuracy: 0.9611 - lr: 1.0000e-05\n",
      "Epoch 12/300\n",
      "152/152 [==============================] - 9s 57ms/step - loss: 0.1611 - accuracy: 0.9510 - val_loss: 0.1192 - val_accuracy: 0.9611 - lr: 1.0000e-05\n",
      "Epoch 13/300\n",
      "152/152 [==============================] - 8s 54ms/step - loss: 0.1603 - accuracy: 0.9539 - val_loss: 0.1198 - val_accuracy: 0.9667 - lr: 1.0000e-05\n",
      "Epoch 14/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.1580 - accuracy: 0.9535 - val_loss: 0.1182 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 15/300\n",
      "152/152 [==============================] - 8s 51ms/step - loss: 0.1456 - accuracy: 0.9535 - val_loss: 0.1201 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 16/300\n",
      "152/152 [==============================] - 8s 53ms/step - loss: 0.1491 - accuracy: 0.9547 - val_loss: 0.1138 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 17/300\n",
      "152/152 [==============================] - 8s 51ms/step - loss: 0.1364 - accuracy: 0.9570 - val_loss: 0.1191 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 18/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.1456 - accuracy: 0.9553 - val_loss: 0.1175 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 19/300\n",
      "152/152 [==============================] - 9s 58ms/step - loss: 0.1448 - accuracy: 0.9568 - val_loss: 0.1132 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 20/300\n",
      "152/152 [==============================] - 8s 54ms/step - loss: 0.1383 - accuracy: 0.9586 - val_loss: 0.1156 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 21/300\n",
      "152/152 [==============================] - 8s 55ms/step - loss: 0.1339 - accuracy: 0.9553 - val_loss: 0.1117 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 22/300\n",
      "152/152 [==============================] - 8s 56ms/step - loss: 0.1351 - accuracy: 0.9562 - val_loss: 0.1125 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 23/300\n",
      "152/152 [==============================] - 9s 57ms/step - loss: 0.1341 - accuracy: 0.9566 - val_loss: 0.1128 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 24/300\n",
      "152/152 [==============================] - 8s 54ms/step - loss: 0.1373 - accuracy: 0.9556 - val_loss: 0.1132 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 25/300\n",
      "152/152 [==============================] - 8s 51ms/step - loss: 0.1273 - accuracy: 0.9605 - val_loss: 0.1127 - val_accuracy: 0.9704 - lr: 1.0000e-05\n",
      "Epoch 26/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.1265 - accuracy: 0.9605 - val_loss: 0.1114 - val_accuracy: 0.9704 - lr: 5.0000e-06\n",
      "Epoch 27/300\n",
      "152/152 [==============================] - 9s 57ms/step - loss: 0.1256 - accuracy: 0.9599 - val_loss: 0.1097 - val_accuracy: 0.9704 - lr: 5.0000e-06\n",
      "Epoch 28/300\n",
      "152/152 [==============================] - 8s 50ms/step - loss: 0.1150 - accuracy: 0.9630 - val_loss: 0.1101 - val_accuracy: 0.9704 - lr: 5.0000e-06\n",
      "Epoch 29/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.1170 - accuracy: 0.9593 - val_loss: 0.1106 - val_accuracy: 0.9704 - lr: 5.0000e-06\n",
      "Epoch 30/300\n",
      "152/152 [==============================] - 8s 55ms/step - loss: 0.1168 - accuracy: 0.9623 - val_loss: 0.1120 - val_accuracy: 0.9704 - lr: 5.0000e-06\n",
      "Epoch 31/300\n",
      "152/152 [==============================] - 8s 51ms/step - loss: 0.1165 - accuracy: 0.9619 - val_loss: 0.1103 - val_accuracy: 0.9704 - lr: 5.0000e-06\n",
      "Epoch 32/300\n",
      "152/152 [==============================] - 8s 52ms/step - loss: 0.1105 - accuracy: 0.9638 - val_loss: 0.1111 - val_accuracy: 0.9704 - lr: 2.5000e-06\n",
      "Epoch 33/300\n",
      "152/152 [==============================] - 8s 55ms/step - loss: 0.1097 - accuracy: 0.9621 - val_loss: 0.1128 - val_accuracy: 0.9704 - lr: 2.5000e-06\n",
      "Epoch 34/300\n",
      "152/152 [==============================] - 8s 54ms/step - loss: 0.1052 - accuracy: 0.9646 - val_loss: 0.1124 - val_accuracy: 0.9704 - lr: 2.5000e-06\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "        train_ds,\n",
    "        validation_data=valid_ds,\n",
    "        # class_weight=class_weight_dict,\n",
    "        epochs=EPOCH,\n",
    "        workers=4,\n",
    "        callbacks=[tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=7, min_delta=1e-4, mode='min'),\n",
    "                  tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', patience=4, factor=0.5, verbose=0)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfhistory = pd.DataFrame(history.history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f9105d49350>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhU5dnH8e+dPYFsQCCBkAQU2feAa1HEBdxoXVHEglqKK9q61mpt1dpaX7ULanG3LkARlSpuVSviggmb7IisIUAChCRA1pn7/eMMECAkEzLJTGbuz3XNNdtZ7hnllzPPec7ziKpijDEmeIX5uwBjjDFNy4LeGGOCnAW9McYEOQt6Y4wJchb0xhgT5CL8XUBt2rVrp1lZWf4uwxhjWowFCxbsUNWU2t4LyKDPysoiNzfX32UYY0yLISIbj/aeNd0YY0yQs6A3xpggZ0FvjDFBLiDb6I0xoaeqqoq8vDzKy8v9XUpAi4mJIT09ncjISK/XsaA3xgSEvLw84uPjycrKQkT8XU5AUlV27txJXl4eXbp08Xo9a7oxxgSE8vJy2rZtayFfBxGhbdu2Df7VY0FvjAkYFvL1O5bvKHiC3u2GuY/D2v/6uxJjjAkowRP0YWHw9d9h9Qf+rsQYYwJK8AQ9QFIG7N7k7yqMMSGgdevWR31vw4YN9OnTpxmrqZtXQS8iI0VktYisFZF7anl/rIh877l9LSL9a7yXJCIzRWSViKwUkZN9+QEOkZQBRUe9CtgYY0JSvd0rRSQcmAKcDeQBOSIyW1VX1FhsPXC6qhaJyChgKnCi572/Ah+q6qUiEgXE+fQT1JSUCWs/BVWwkzrGtFi//89yVuSX+HSbvTom8LsLex/1/bvvvpvMzExuvPFGAB588EFEhLlz51JUVERVVRUPP/wwo0ePbtB+y8vLueGGG8jNzSUiIoInnniC4cOHs3z5ciZMmEBlZSVut5u33nqLjh07cvnll5OXl4fL5eL+++/niiuuaNTnBu/60Q8F1qrqOgARmQaMBg4Evap+XWP5b4F0z7IJwDBgvGe5SqCy0VUfTXImVJfB3h3QutZB3IwxplZjxozhtttuOxD0M2bM4MMPP+T2228nISGBHTt2cNJJJ3HRRRc1qOfLlClTAFi6dCmrVq3inHPOYc2aNTz77LNMnjyZsWPHUllZicvlYs6cOXTs2JH3338fgOLiYp98Nm+CvhOwucbzPA4erdfmOmD/GdGuQCHwkqc5ZwEwWVX3Hr6SiEwEJgJkZGR4UVYtkjzr7d5kQW9MC1bXkXdTGThwIAUFBeTn51NYWEhycjJpaWncfvvtzJ07l7CwMLZs2cL27dtJTU31ervz5s3jlltuAaBHjx5kZmayZs0aTj75ZB555BHy8vK4+OKL6datG3379uWOO+7g7rvv5oILLuAnP/mJTz6bN230tf3p0loXFBmOE/R3e16KAAYBz6jqQGAvcEQbP4CqTlXVbFXNTkk5xpA+EPQbjm19Y0xIu/TSS5k5cybTp09nzJgxvP766xQWFrJgwQIWL15Mhw4dGnyxkmqtcclVV13F7NmziY2N5dxzz+Wzzz7jhBNOYMGCBfTt25d7772XP/zhD774WF4FfR7QucbzdCD/8IVEpB/wPDBaVXfWWDdPVed7ns/ECf6mUfOI3hhjGmjMmDFMmzaNmTNncumll1JcXEz79u2JjIzk888/Z+PGhnf2GDZsGK+//joAa9asYdOmTXTv3p1169bRtWtXbr31Vi666CK+//578vPziYuL4+qrr+aOO+5g4cKFPvlc3jTd5ADdRKQLsAUYA1xVcwERyQBmAeNUdc3+11V1m4hsFpHuqroaGEGNtn2fi46H2DYW9MaYY9K7d29KS0vp1KkTaWlpjB07lgsvvJDs7GwGDBhAjx49GrzNG2+8kUmTJtG3b18iIiJ4+eWXiY6OZvr06bz22mtERkaSmprKAw88QE5ODnfeeSdhYWFERkbyzDPP+ORzydF+VhyykMh5wFNAOPCiqj4iIpMAVPVZEXkeuATY/+euWlWzPesOwDnSjwLWARNUtaiu/WVnZ+sxzzD1z9OhVTu4+q1jW98Y4xcrV66kZ8+e/i6jRajtuxKRBftz93BejV6pqnOAOYe99myNx9cD1x9l3cVArTtvEkkZULCy2XZnjDGBLviGKU7OhB8+tr70xpgmt3TpUsaNG3fIa9HR0cyfP/8oa/hH8AV9UiZUl8OeAojv4O9qjDFBrG/fvixevNjfZdQruMa6gRo9b2woBGOMgaAM+kzn3nreGGMMEJRB7+nyb0f0xhgDBGPQR7WCuHZ2RG+MabC6hh5uyYIv6MGGKzbGmBqCM+iTM+2I3hhzzFSVO++8kz59+tC3b1+mT58OwNatWxk2bBgDBgygT58+fPnll7hcLsaPH39g2SeffNLP1R8p+LpXgnNEv+p9Zx7ZsOD8W2ZMUPvgHti21LfbTO0Lo/7k1aKzZs1i8eLFLFmyhB07djBkyBCGDRvGG2+8wbnnnst9992Hy+Vi3759LF68mC1btrBs2TIAdu/e7du6fSA4UzApA1yVsGebvysxxrRA8+bN48orryQ8PJwOHTpw+umnk5OTw5AhQ3jppZd48MEHWbp0KfHx8XTt2pV169Zxyy238OGHH5KQkODv8o8QpEf0Wc797k2Q0NGvpRhjjoGXR95N5WhjgA0bNoy5c+fy/vvvM27cOO68806uueYalixZwkcffcSUKVOYMWMGL774YjNXXLfgPaIHa6c3xhyTYcOGMX36dFwuF4WFhcydO5ehQ4eyceNG2rdvzy9+8Quuu+46Fi5cyI4dO3C73VxyySU89NBDPhta2JeC9Ije+tIbY47dz372M7755hv69++PiPDYY4+RmprKK6+8wl/+8hciIyNp3bo1r776Klu2bGHChAm43W4AHn30UT9XfySvhilubo0apni/v3SDE86F0f/wTVHGmCZlwxR7r6HDFAdn0w1YF0tjjPEI3qBPyrCgN8YYvAx6ERkpIqtFZK2IHDG5t4iMFZHvPbevRaT/Ye+Hi8giEXnPV4XXKykDivPA7Wq2XRpjGicQm5IDzbF8R/UGvYiEA1OAUUAv4EoR6XXYYuuB01W1H/AQMPWw9ycDzTvtU1ImuKugdGuz7tYYc2xiYmLYuXOnhX0dVJWdO3cSExPToPW86XUzFFirqusARGQaMJoak3yr6tc1lv8WSN//RETSgfOBR4BfNai6xqjZxTIxve5ljTF+l56eTl5eHoWFhf4uJaDFxMSQnt6wTPMm6DsBm2s8zwNOrGP564APajx/CrgLiK9rJyIyEZgIkJGR4UVZ9ag5Ln3mKY3fnjGmSUVGRtKlSxd/lxGUvGmjr23i1Vp/W4nIcJygv9vz/AKgQFUX1LcTVZ2qqtmqmp2SkuJFWfXYfxRvo1gaY0KcN0f0eUDnGs/TgfzDFxKRfsDzwChV3el5+VTgIhE5D4gBEkTkNVW9unFleyEyBuLTrOeNMSbkeXNEnwN0E5EuIhIFjAFm11xARDKAWcA4VV2z/3VVvVdV01U1y7PeZ80S8vslZdjVscaYkFfvEb2qVovIzcBHQDjwoqouF5FJnvefBR4A2gJPiwhA9dGu0GpWSRmw+Tt/V2GMMX7l1Vg3qjoHmHPYa8/WeHw9cH092/gf8L8GV9gYSZmwbBa4qiE8OIf1McaY+gTvlbHgHNGrC0qPOKVgjDEhI/iDHuyErDEmpIVG0FsXS2NMCAvuoE/sDIgd0RtjQlpwB31ElDOVoAW9MSaEBXfQgw1XbIwJeSES9NZGb4wJXSEQ9JlQsgVcVf6uxBhj/CIEgj4D1O2EvTHGhKDQCHqwLpbGmJAV/EGfXGNcemOMCUHBH/QJnUDCLOiNMSEr+IM+PNIJewt6Y0yICv6gB+tiaYwJaSES9Jl2RG+MCVkhEvQZUJIP1ZX+rsQYY5qdV0EvIiNFZLWIrBWRe2p5f6yIfO+5fS0i/T2vdxaRz0VkpYgsF5HJvv4AXknKABRK8vyye2OM8ad6g15EwoEpwCigF3CliPQ6bLH1wOmq2g94CJjqeb0a+LWq9gROAm6qZd2mt7+LpfWlN8aEIG+O6IcCa1V1napWAtOA0TUXUNWvVbXI8/RbIN3z+lZVXeh5XAqsBDr5qniv2QQkxpgQ5k3QdwI213ieR91hfR3wweEvikgWMBCYX9tKIjJRRHJFJLewsNCLshogviNIuAW9MSYkeRP0UstrWuuCIsNxgv7uw15vDbwF3KaqJbWtq6pTVTVbVbNTUlK8KKsBwiMgsZN1sTTGhKQIL5bJAzrXeJ4OHDHbtoj0A54HRqnqzhqvR+KE/OuqOqtx5TaCdbE0xoQob47oc4BuItJFRKKAMcDsmguISAYwCxinqmtqvC7AC8BKVX3Cd2UfAwt6Y0yIqveIXlWrReRm4CMgHHhRVZeLyCTP+88CDwBtgaedbKdaVbOBU4FxwFIRWezZ5G9UdY7vP0o9kjKgdCtUV0BEdLPv3hhj/MWbphs8wTznsNeerfH4euD6WtabR+1t/M3vwCiWm6Hd8f6txRhjmlFoXBkLNbpY2glZY0xoCcGgt3Z6Y0xoCZ2gj0+DsEg7ojfGhJzQCfqwcEhMtyN6Y0zICZ2gB8+49Bb0xpjQYkFvjDFBLrSCPjkT9myHqjJ/V2KMMc0mtII+qUZfemOMCREhFvTWxdIYE3pCNOiti6UxJnSEVtC3ToXwKAt6Y0xICa2gDwuDxM6w80fQWofUN8aYoBNaQQ/QaTCseg+mng6L34Cqcn9XZIwxTSr0gv7Cv8IFT0F1JbxzAzzZGz59CEqOmEvFGGOCgmgANmFkZ2drbm5u0+5EFdbPhfn/hNVznCESel4EJ06CzkNBAmN0ZWOM8YaILPDMA3IEr8ajD0oi0PV057ZrPeQ8Dwv/BctnQdoAOPlm6HupBb4xpsXzqulGREaKyGoRWSsi99Ty/lgR+d5z+1pE+nu7bkBo0wXOfQR+vRIueBKqy2HW9fDyBbBjrb+rM8aYRqk36EUkHJgCjAJ6AVeKSK/DFlsPnK6q/YCHgKkNWDdwRLWC7Gvhhm/gwr/B9qXwzCkw9y9Om74xxrRA3hzRDwXWquo6Va0EpgGjay6gql+rapHn6bdAurfrBqSwMBj8c7gpB7qPgs8ednrp5DXxeQNjjGkC3gR9J6Dm4DB5nteO5jrgg4auKyITRSRXRHILCwu9KKsZxHeAy1+BK6dBeTE8fxbMuQsqSv1dmTHGeM2boK/tbGStXXVEZDhO0N/d0HVVdaqqZqtqdkpKihdlNaPuo+Cm+TB0Inw3FaacCKs/qH89Y4wJAN4EfR7QucbzdOCITuci0g94Hhitqjsbsm6LEB0P5z0G130CMYnw5hj493i74MoYE/C8CfocoJuIdBGRKGAMMLvmAiKSAcwCxqnqmoas2+J0HgITv4Az7oXlb8P30/xdkTHG1KneoFfVauBm4CNgJTBDVZeLyCQRmeRZ7AGgLfC0iCwWkdy61m2Cz9G8IqLg9LuhQx+n/30AXnRmjDH7he6Vsb6Q8wK8/yu47r/Okb4xxvhJXVfGht5YN77U73KIag25L/i7EmOMOSoL+saIjod+V8CyWbBvl7+rMcaYWlnQN9aQ68BVAYte83clxhhTKwv6xurQGzJOhtwXwe32dzXGGHMEC3pfyL4OitbDus/9XYkxxhzBgt4Xel0Ece2co3pjjAkwFvS+EBENg8Y5E5gU5/m7GmOMOYQFva8MnuBcOLXgFX9XYowxh7Cg95XkTOh2Nix8BVxV/q7GGGMOsKD3pSHXw57tsOo9f1dijDEHWND70vFnQWKGMzSCMcYECAt6XwoLh+zxsOFLKFxT7+LGGNMcLOh9beA1EBZpXS2NMQHDgt7XWqdAr9Gw+A2o3OvvaowxxoK+SQy5DiqKYdlb/q7EGGMs6JtExsmQ0tMmJTHGBASvgl5ERorIahFZKyL31PJ+DxH5RkQqROSOw967XUSWi8gyEXlTRGJ8VXzAEnGO6rcugS0L/V2NMSbE1Rv0IhIOTAFGAb2AK0Wk12GL7QJuBR4/bN1OntezVbUPEI4zb2zw63cFRLaySUmMMX4X4cUyQ4G1qroOQESmAaOBFfsXUNUCoEBEzj/KPmJFpAqIA/IbXXVLEJPgzEC15E047XaISYLwSAiPcm5h4c6R/+HcLqgqg+ryI++Ts6B1+2b/KMaYls2boO8EbK7xPA840ZuNq+oWEXkc2ASUAR+r6se1LSsiE4GJABkZGd5sPvANuQ4WvAT/qG0aR6kR/JHOWPZV+8Bdx/AJMYnwyy+d4RaMMcZL3gR9LYedeHWGUUSScY7+uwC7gX+LyNWqesR0TKo6FZgKzuTg3mw/4KX2havfguIt4Kp0xsCpee+uch5XVzhH+JGxEBELkTGH3ceCuuHdm+Ct62DCB84fB2OM8YI3QZ8HdK7xPB3vm1/OAtaraiGAiMwCTgFCZ96948/y3bbcVTDzWvj8ETjrQd9t1xgT1LzpdZMDdBORLiIShXMydbaX298EnCQicSIiwAhg5bGVauhzCQz6Ocx7Cn78zN/VGGNaiHqDXlWrgZuBj3BCeoaqLheRSSIyCUBEUkUkD/gV8FsRyRORBFWdD8wEFgJLPfub2kSfJTSM/BOkdIdZv4Q9Bf6uxhjTAogG4AU92dnZmpub6+8yAtf25fDcmZB5Cox9C8LsujdjQp2ILFDV2np+2JWxLVKH3jDyUaf55uu/+bsaY0yAs6BvqQZPcAZP++wh2Jzj72qMMQHMgr6lEoEL/wbxHeGta6Fst78rMsYEKAv6liw2CS590emn/5/JNoCaMaZWFvQtXechMOJ+WPEOLHi57mVdVVCwEn74xBlWwRgTEry5YMoEulMmw7ov4MN7oPOJ0KEX7N0B25fBtmVOL53ty6BwlXNFLkBqP7jiX874OcaYoGbdK4PFngJ45lRAQcJgz/aD77XuAB36OL11OvRxlplzl9POf/FzcMI5/qraGOMjdXWvtCP6YNG6PVz6Anz6ELQ9HlI9wd6+tzO94eE6D4Xp18Abl8Ppd8Hpdzvj7Rhjgo4d0YeyqjJ471ew5A04bgRc8jzEtfF3VcaYY2AXTJnaRcbCT5+GC56CDV/CP0+3GbGMCUIW9KFOBLInwLUfAgovnuv03gnAX3rGmGNjQW8cnQbDxC8g6zSnT/67N1sXTGOChAW9OahVWxg7E4bdBYtfg78NgpznnYlRjDEtlgW9OVRYOJx5H4yfA0kZ8P6v4e+DYcErzgVXxpgWx4Le1C7rVKfd/upZTj/8/9zqBP6i18FV7e/qjDEN4FXQi8hIEVktImtF5J5a3u8hIt+ISIWI3HHYe0kiMlNEVonIShE52VfFmyYmAsePgOv/C1f9G2KT4d0bYcpQ+H4GuF3+rtAY44V6+9GLSDiwBjgbZ/7YHOBKVV1RY5n2QCbwU6BIVR+v8d4rwJeq+rxnKsI4Va1zqEXrRx+gVGH1HPj8j86QCu1OgN4X13+hVXgUJHSEhE6e+44QEd08NRsTIhp7ZexQYK2qrvNsbBowGjgQ9KpaABSIyPmH7TgBGAaM9yxXCVQew2cwgUAEepwPJ4yClbPhiz/DF386tm21SvEEvyf8kzLguDOdq3lFfFu3MSHOm6DvBGyu8TwPONHL7XcFCoGXRKQ/sACYrKp7G1SlCSxhYdD7p87EJ+quf/mqMijJh5ItNe63OMMrF22AjfOgvBg+uR+SMp0/Jj3Oh84nQbiN0mFMY3nzr6i2wytvr6aJAAYBt6jqfBH5K3APcP8ROxGZCEwEyMjI8HLzhxWlitjRYPMRAfFifJzo1pBygnM7mtLtsOZDWPU+5LwA3z4NsW2g+ygn9LsOh6g439VuTAjx5mRsHtC5xvN0IN/L7ecBeao63/N8Jk7wH0FVp6pqtqpmp6TUMghXPfZWVPOLV3P5zxJvSzMBJb4DDP45jJ0Bd/0Il70Cx58Fq96DaVfBY13hzatg1zp/V2pMi+NN0OcA3USki+dk6hhgtjcbV9VtwGYR6e55aQQ12vZ9KTI8jOKyKu6cuYRlW4qbYhemuUTHO01DlzwHd/4I17wLg8Y54/G8PcmGZzCmgeoNelWtBm4GPgJWAjNUdbmITBKRSQAikioiecCvgN+KSJ7nRCzALcDrIvI9MAD4Y1N8kKiIMJ65ejBt4qL4xau5FJba1ZxBITwSup4B5/0Fzn0ENs+HJdP8XZUxLUrQDVO8PL+YS5/5hp5p8bw58SSiI2yM9aDhdsMLZ8PuTXBLLsQk+rsiYwJGSA1T3LtjIo9f1p+Fm3Zz39vLCMQ/ZOYYhYU5R/Z7C+HzR/1djTEtRtAFPcD5/dK4dUQ3Zi7I48WvNvi7HONLnQbB4PHw3VRnLlxjTL2CMugBbhvRjXN7d+CR91cwd02hv8sxvjTiAYhJgDl32olZY7wQtEEfFiY8cfkATugQz81vLGRd4R5/l2R8Ja4NjPgdbPwKls70dzXGBLygDXqAVtERPHdNNhHhYVz/ai4l5TbMbtAYdA10HAgf/xbKS/xdjTEBLaiDHqBzmzieHjuITTv3ceubi3C57ad+UAgLh/Mehz3bnDF3jDFHFfRBD3BS17b8fnRv/re6kMc+XOXvcoyvpGfDwHEw/1kosP+uxhxNSAQ9wNgTMxl3Uib/nLuON+Zv8nc5xlfOehCiWsEHXp6YVYV1/4MfPmniwowJHCET9AAPXNiL045vx2/eXsqkfy2goKTc3yWZxmrVDs68H9bPheVvH305twtWvAtTz4BXR8MbV9ivABMyQiroI8PDeGnCEO48tzufrS7grCe+YHrOJruoqqXLvhZS+8FH90HFYb2rqith4b9gyokw4xqoKIFRjzkjan5wl3XPNCEhpIIenLC/afjxfDD5J/RITeDut5Yy9vn5bNxpQ+S3WGHhcP7/QWk+zP2L81rFHvhmCvy1P8y+GSJj4dKX4OZcOPGXMPy3sP4LZ3RMY4Jc0I110xBut/LGd5v40werqHa7+fXZ3ZlwahYR4SH39y84vHOjM5ftib+Exa9DWRFk/QROuw2OG3HozFWuavjnT6ByD9z0nfOH4FiUbHXuW7evf0pFY5pQXWPdhHTQ77e1uIzfvr2MT1cV0C89kT9f0o+eaQn1r2gCy55C+PtgqCiG7ufBab+CzkOOvvz6ufDKhTD8Pjj9robvb9ksmHktoM4ELPGpEJ8GCWnOFInxaQfnyE0fYvPkmiZlQe8FVeU/32/l97OXU1xWxQ1nHMctZ3YjKsKO7luUglUgYXXPZlXTjJ/Dmo/g5hxI6lz/8vttWwovnAMd+kD/K5wj+9KtnmkSPY8ralzIldYfrvq3M8GKMU3Agr4BivZW8tB7K5i1aAu9Oybw5BXOMAomSO3eBP8Y4vwCuOwl79bZtwumng6uKpj4xdHDu6LUCf38hfDeryCuLVw9E1K61768MY0QUsMUN1ZyqyieuGIAU8cNZltxORf8fR4vzFuP266oDU5JGXDa7bB8FmyYV//yrmr493go3QZXvF73EXp0vPPLov8YmPA+VJc7vwI2fuOz8o3xhldBLyIjRWS1iKwVkXtqeb+HiHwjIhUickct74eLyCIRaTFdHM7pncqHtw1jWLd2PPTeCq5+YT5bdpf5uyzTFE6dDIkZ8MHdTpDX5b+/c3rrXPAkpA/2fh8dB8L1n0CrFKcff119/o3xsXqDXkTCgSnAKKAXcKWI9DpssV3ArcDjR9nMZJxpCFuUlPhonrsmmz9d3Jclm3cz8sm5vL0oz/rdB5vIWDj3Ydi+DBbU0XyzZDp88w8Y+ksYeHXD95OcBdd97IT+vyc43T+NaQbeHNEPBdaq6jpVrQSmAaNrLqCqBaqaAxwxPKSIpAPnA8/7oN5mJyKMGZrBB5OH0T01ntunL+GmNxZStLfS36UZX+p5EXQZBp897LTBHy5/EfznVsg8zZm79ljFtYFr3oGeF8JHv4EP73WmSDSmCXkT9J2AzTWe53le89ZTwF1Ai/6/OaNtHNN/eTJ3jezOJyu2c+5Tc/l8dYG/yzK+IgIj/+ycQP3s4UPf21MI066GuHZw2cvOhOWNERnrbOekG+Hbp2HmeKiy4ThM0/Em6KWW17xquxCRC4ACVV3gxbITRSRXRHILCwNzRqjwMOHGM47nnZtOJSkukgkv5fCvbzb4uyzjKx16wZDrneabbUud11xV8O+fw74dMOY1aJ3im32FhcPIR+HcP8KK2U67fW2/JIzxAW+CPg+o2cE4Hcj3cvunAheJyAacJp8zReS12hZU1amqmq2q2SkpPvrH1ER6d0xk9s2ncVbPDtz/7nJen7/R3yUZXxl+L8QkOSdmVZ3mlY1fwYV/c9rWfe3km5xunfmL4NmfOKFv54CMj3kT9DlANxHpIiJRwBhgtjcbV9V7VTVdVbM8632mqsdwFivwxESGM2XsQM7s0Z773l7Gm9/Z0MdBITbZmZN241cwc4IzCfnJNzsXRTWV3j+DCXMgNglmjIPXLoGdPzbd/uqjCptz4J2bIOcF/9VhfKbeoFfVauBm4COcnjMzVHW5iEwSkUkAIpIqInnAr4DfikieiAT9GALREeE8c/UghndP4d5ZS5mRs7n+lUzgG3SNMxrm8rehy+lw1u+bfp/p2c7FVyP/DHk58PRJ8OlDULmv6fe9X1U5LH7DGcr5hbOc8YLm3AHrv2y+GkyTsCtjfaC8ysUv/7WAuT8U8tgl/bgsuwGX0pvAtPV7pyvlyD85PWWaU+l2+OQB+H4aJHZ22vJ7XHDooGx1qSqDiBjvl9+9GXJfgAWvQNkuSOkBQ38BPS6El89zRgK94Stn7H8TsGwIhGZQXuXiF6/mMm/tDh6/tD+XDE73d0mmpdvwFcy5EwqWw/FnOePotz3u4Pt7CqFw1cFbwSooXAn7dkJ0IiRnOH33k7MgKROSu3ged4bwKGdQt++mwuo5zva6nwdDJzrdTPf/kdi2FJ4bAVmnwdiZEGYX0wcqC/pmUl7l4rpXcvj6x508efkAfjqwIb1QjamFqxpynoPPHgFXhdPfv3TbwUDfLzrRGUOnfQ9nWIc9BVC0EYo2wO6Nzi1xA2QAABRdSURBVPALBwjEJEL5bohtA4N/7kzekpRRew25L8J7tzvTNp52e9N9VtMoFvTNqKzSxbUv5zB//U6evGIAowdY2BsfKN3mNOes/dQ5qk/p4dzae+7j047eVON2w57tB0O/aAMU50HGydDnEoiMqXvfqs6J6RWznZPGGSf5+tMZH7Cgb2b7KquZ8FIOORt28bcrB3JBv47+LsmYxikvhn8Oc35hTPqy+c9bmHrZ6JXNLC4qgpcmDCE7sw2Tpy3m4fdWsH6HTVVoWrCYROdq3j3bnZm8AvAA0RydBX0T2R/2F/RL4+WvNzD88f8x9vlvmbN0K1WuFj0ahAlVHQfCOQ/Dmg+coRtMi2FNN82goKScGbmbefO7zWzZXUZKfDRXZHdmzNDOpCfH+bs8Y7ynCtOvdmbluvajhg3VbJqUtdEHCJdb+WJNAa9/u4nPPAOiDe/enrEnZjDshBQibVJy0xKUFcGzni6Yv5zrXNFr/M6CPgDlFe1jes5mpuVsprC0gogwIT05lsy2rchqG0dWu1ZktW1FZts40pPjbO5aE1g258BLI52+95e/6v3FWabJWNAHsCqXm89WFfB93m427NzHxp172bBjH3sqDs50FB4mdEqKZUhWG+49rwftWkf7sWJjPL76G3xyPwy7C04YCYmdoFV7u6jKTyzoWxhVZefeygOhv2HnXtbt2Msny7fTOiaCh3/ah/P6pvm7TBPq3G6YdpVzcna/sAiI7+iEfkJHSOgEienOfVJn56KsmCT7BdAELOiDxJrtpfx6xhKWbinmwv4d+cNFvUluFeXvskwoc7ucKRiLt0DJ/lt+jef5zhW9NUUnOIGf6An+/be2x0GH3v75HEHAgj6IVLnc/POLH/nrpz+QGBvFH3/Wh3N6p/q7LGNqp+oM1VC82Rk8bfcm51bseVy0ESpLDy5/9kNw6q3+q7cFs6APQiu3lvDrGUtYsbWEiwd24ncX9iYxrpFT3BnT3FSdMXd2b4b/PQo/fAK/+AzS+vm7shbHrowNQj3TEnjnplOZPKIbs5fkc/aTX/DZqu3+LsuYhhFxJntJ6wcX/cMZWmHWRJtD18fsiD4ILNtSzK9nLGH19lJG9Uklo00cEeFCZHgYkeFhRITtfyxEhIcRFxXOmT3aEx/TuF8APxbuoaLKTa+OQT/HjGkuP/wXXr/EmTh95KP+rqZFaXTTjYiMBP4KhAPPq+qfDnu/B/ASMAi4T1Uf97zeGXgVSAXcwFRV/Wt9+7Ogb7iKahd/+/QHXvt2E+VVLqrdist99P+2bVtFcdtZ3RgzNKPBF2ptLS7j/z5ew1sL81CF7Mxkrv9JF87ulUp4mPWmMI30/h3O0Mzj3oHjhvu7mhajUUEvIuHAGuBsnInCc4ArVXVFjWXaA5nAT4GiGkGfBqSp6kIRiQcWAD+tuW5tLOh9w+1Wqtxuql1KlctNlUupdrvJKyrj8Y9WM3/9LrqmtOLeUT05q2d7pJ4ub6XlVTz7xY+8MG89bjeMPzWL1IQYXvp6PZt3lZHRJo5rT83isuzOtIqOaKZPaYJO5T6YevrBma1spEyvNDboTwYeVNVzPc/vBVDVI35XiciDwJ79QV/L++8C/1DVT+rapwV901NV/ruygEc/WMm6wr0M7dKG+87rSf/OR17OXuVyM+27TTz13x/YubeS0QM6csc53encxhmnx+VWPl6+jee+XMfCTbtJiIngqhMzGX9KFqmJ9Yx17kO791WSs6GIbu1bk9WuVbPt1zSB/EXw/FnQazRc+qK/q2kR6gp6bw67OgE1Z73OA048hiKygIHA/Iaua3xPRDi7VwfO6J7CtJzNPPXJGkZP+eqQEFdVPl6xnT9/sIp1O/ZyYpc2vHR+T/qlH/rHIDxMGNU3jVF901iwsYgX5q1j6twfef7LdVzYvyMX9k9jX6WLXXsrD9x27q1k155KivY5j/dVVNM9NZ6BGckMzEhiYEYyHRNj6vyVUV7lIndDEfPW7uDrH3ewdEsxqhAXFc7frxzIiJ4dGvUdlVW6iI0Kb9Q2zDHqOBDOuAc+exhOGAX9LvN3RS2aN0f0lwHnqur1nufjgKGqekstyz5ILUf0ItIa+AJ4RFVnHWU/E4GJABkZGYM3btzY8E9jjtn+Zpnnv1yPKow9KYPlW0r4bsMujvM074zwonlnv8279vHiV+uZkbOZvZWuQ95LjI2kbaso2rSKIrlVFG1bRREdEcby/BKWbimmotoZxjklPpqBnZMOhH/vjgn8WLiXr9bu4Ku1O8jdWERltZuIMGFQRjKnHN+WgRnJPP7RapbnF/PABb0Yf2qXBn8Xxfuq+M3bS3l/6VY6JcUe+MMzKCOJXh0TiI6w8G8WrmpncvKCVU4TTlJnf1cU0PzadCMikcB7wEeq+oQ3BVvTjf/k73ZOtM5alOc5YXsCY4Z0JuIYR9YsLqti1dYSkuKcYE+Ki6zz5G+Vy82qraUs2lzEok27WbSpiA079x2xXI/UeE47vh2ndmvH0Kw2h5wT2FdZzeRpi/lkxXbGn5LF/Rf08vok8fx1O7l9+mIKSiu4+qRMCvdUsGhjEfnFTne/qIgw+nRM8AR/MoMyk0hLjG3gt2K8tms9PHuac4R/zWwbR6cOjQ36CJyTsSOALTgnY69S1eW1LPsgNYJenMO/V4BdqnqbtwVb0Pvf9pJy4mMiiIvy/0nVXXsrWbJ5N8vzi8lo24pTjmtb78BuLrfyxzkreWHees7q2Z6/jhlY5wniKpebv336A1M+X0tGmzj+OmbgIecrthWXs2hTEYs272bhxqJDfnmc1zeVe0f1PHDOwvjYwldh9i3OpCenHNGQcKi9O2H9F87wC2GREB4B4VGex5HOWDzhkc7ziCiIjIPIWM99HER57sNb3sWHvuheeR7wFE73yhdV9RERmQSgqs+KSCqQCyTgdKPcA/QC+gFfAks9rwP8RlXn1LU/C3rjK69+s4EHZy+nV8cEXvj5EDokHHlyeNPOfUyevohFm3Zz2eB0Hryod729hiqr3azcWsJ/V27nuS/X4VaY+JOu3HDGcdbjyNf2T3byw8fwi88htc/B96rKYNO3sO5z+PFz2Pa9b/YZFgGRrZwePyMfhe6jfLPdJmRDIJiQ9vmqAm5+YyEJsZG8OH4IPdMOXuD1zqIt/PadZYjAIz/ry0X9Gz6Re/7uMv784SreXZxP+/ho7hrZg4sHdiLMi+ai4rIqPl25nQ+XbSMmMpxbRxzP8e3jG1xD0Nu7A54+GVqlwOi/w/ovnXDf9C1UlztH6J1PhK5nOH3v23VzBlxzVYG7yrmv+dhdDdUVzh+Kqn2e+73OfeW+g69tmOcM2jb8Phh2R0CPumlBb0Le8vxirns5l9LyKqaMHcTgzGQeeHc5by/aQnZmMk9eMaDRTS8LNhbxh/dWsGTzbvqnJ/LAhb0YnHlkH/DifVV8vGIbHyzbxpc/FFLlUlITYthTUc2+ymouGZTObWefQKcka/s/xJqP4I3LDz5v3wu6DnfCPfMUiG7t+31WlcF/JsP306HnRfDTZ5pmPz5gQW8MTjv7tS/nsGpbCe3jYygoLefWEd24efjxx3yy+XBut/LO4i38+cNVbC+p4KL+HblnVA/iosL5ePl25izbyldrd1DlUjolxTKqTyrn9UtjQHoSRfsqefp/P/KvbzaCwDUnZXLj8ONpY0NRH7R0pnM03vUMiG+mUVtV4ZspziQrKT1hzOvQpuG9uZqaBb0xHnsrqrl9+mJWby/l/y7rT3ZW01x1ubeimme/+JGpc9ehOH8Aqt1KenIs5/VN47y+afRPT6y1u2pe0T6e+u8PzFqYR6uoCCYO68q1p3VpcNu/qlLlUsqrXZRXuaioclNR7aK8yk15lYu9lS72lFezt6Ka0grnfs/+m+f1sDAhISaSxNhIEmIjnPsDz537lPjo0Phj9OPn8O/xzuPLXvZ6eIaKahcr8kvYV+kiPiaChBjnu4uPifDpPNEW9MYcRlW9viagMfKK9vHPL9YRFx3O+X3T6Nup9nCvzZrtpTz+0Wo+XrGddq2juOXMblw5NIPyahfbisvZWlzOtuIythVXsK2kzPO8nILSCsoqXZRXu2joP++YyDBaR0fSOjqcVtERuNxKSVkVJeXVh0xvebh2raPpkRrPCR3i6ZEaT/fUeLp1aB0QvbYOp6rkFZWxa28l3VPjiYlswHURu9Y7s2oVrnLGzj/5piPa7QtLK1i4qYiFG4tYsLGI77cUU1ntrnVzsZHhJMQeDP/UhBimjB10TJ/Lgt6YFmzBxiL+/OEqvlu/i4gwobqWweratY4mLTGG1MQY2sdH0yo6guiIMGIiw4mOCCM6MpyYGs9jIp0gbx0dQeuYCFpHRdAqOrzOJqxql5vS8mpKyqsoLquipKya4rIqthaXsXpbKau3l7JmeynlVU6oiUBGmzi6d4inR1oCgzwXniXGNl/XxcpqNz8UlLI8v4QV+SWs2FrCyvwSSj1/tKLCw+jTKYHBmc51EYMzk2lfS8+sQ1TsgXdugJWzqeh1GT8MfYTF28qdYN9UxEbPdR+Hb7tNq6gD319JWVWNx859aXk10RFhvDB+yDF9Vgt6Y1o4VeWLNYV8/eNOUlpHk5oYQ1piDB0SnFtURGBcSORyK5t37WPVNif0V28rZdW2Etbv2ItbnfA/oX08gzKTyc50gjWzbVyDfl2pKhXVborL9v/B8dyXV1G8z/n1sWnXPpbnl7C2oJQql5NxsZHh9EyLp1fHBHqlJZIUF8mSzbtZuKmIJXkHj7rTk2MPhH6vjgmUlFWR7/n1tHW380tq6+59jC6dxuSwGSzTLF6pPpeymPakdMoiq8vx9DuuM707Jjbs10IjWdAbY/xqb0U1SzbvJtfTnLFwUxGl5c5RdbvWUQzKSGZARhKCsKeiij3lznmD0nLnfMH+cwelniPgSlftTSH7tWsdTe+OCZ5QT6B3xwQy27Y66hXSldVulucXs3DT7gNNLttKDp38JDxMSE2IOfBHNi0xhqGV33HGit8SWVV66AajWkN8GiSkOZOlJ6TB8WdB1mnH/iXWw4LeGBNQ3G5lTUEpCzYWsWBDEbkbi9i0y2nyCA8Tp0kpOoL4GOfmNDFF0jo64kCbdmLswVtCjce+OsmZv9tpkkpuFUVaYgztWkfX/oeiqty5Erd0K5RshdL8w+49N3c19LkUzv0jxDduwL3aWNAbYwJeSXkVkWFhxESGNcuJ8mZVVQ7znoR5T0BEDJx5Pwy5DsJ817Rjc8YaYwJeQkwksVHhwRfyAJExMPxeuPFb6DQYPrgTnhsOeQuaZfcW9MYY01zaHgfj3oZLX4LS7fD8CHjvdigratLdWtAbY0xzEoE+F8PNOXDSDbDgZfh7Nix+kwZf+OAlC3pjjPGHmARnZMyJXzhDKrwzCV4+Hyr3+nxXgXfZmjHGhJK0fnDtx7DoVcjLhSjfz3dsQW+MMf4WFgaDxzu3pth8k2zVGGNMwPAq6EVkpIisFpG1InJPLe/3EJFvRKRCRO5oyLrGGGOaVr1BLyLhwBRgFM70gFeKSK/DFtsF3Ao8fgzrGmOMaULeHNEPBdaq6jpVrQSmAaNrLqCqBaqaA1Q1dF1jjDFNy5ug7wRsrvE8z/OaN7xeV0QmikiuiOQWFhZ6uXljjDH18Sboa7se2dte/V6vq6pTVTVbVbNTUlK83Lwxxpj6eBP0eUDnGs/TgXwvt9+YdY0xxviAN0GfA3QTkS4iEgWMAWZ7uf3GrGuMMcYHvBqmWETOA54CwoEXVfUREZkEoKrPikgqkAskAG5gD9BLVUtqW9eL/RUCG4/xM7UDdhzjuv5kdTcvq7t5Wd1NL1NVa233Dsjx6BtDRHKPNiZzILO6m5fV3bysbv+yK2ONMSbIWdAbY0yQC8agn+rvAo6R1d28rO7mZXX7UdC10RtjjDlUMB7RG2OMqcGC3hhjglzQBH1LHg5ZRDaIyFIRWSwiuf6u52hE5EURKRCRZTVeayMin4jID577ZH/WWJuj1P2giGzxfOeLPdd7BBQR6Swin4vIShFZLiKTPa8H9HdeR90B/Z2LSIyIfCciSzx1/97zekB/394IijZ6z3DIa4CzcYZdyAGuVNUVfi3MSyKyAchW1YC+MENEhuFcDPeqqvbxvPYYsEtV/+T5A5usqnf7s87DHaXuB4E9qvp4Xev6k4ikAWmqulBE4oEFwE+B8QTwd15H3ZcTwN+5iAjQSlX3iEgkMA+YDFxMAH/f3giWI3obDrkZqOpcnLkHahoNvOJ5/ArOP+iAcpS6A56qblXVhZ7HpcBKnNFfA/o7r6PugKaOPZ6nkZ6bEuDftzeCJegbM5RyIFDgYxFZICIT/V1MA3VQ1a3g/AMH2vu5noa4WUS+9zTtBPTPcRHJAgYC82lB3/lhdUOAf+ciEi4ii4EC4BNVbVHf99EES9A3ZijlQHCqqg7CmYnrJk9Tg2lazwDHAQOArcD/+becoxOR1sBbwG2qWuLverxVS90B/52rqktVB+CMtDtURPr4uyZfCJagb9HDIatqvue+AHgbpymqpdjuaZPd3zZb4Od6vKKq2z3/qN3AcwTod+5pK34LeF1VZ3leDvjvvLa6W8p3DqCqu4H/ASNpAd93fYIl6FvscMgi0spzwgoRaQWcAyyre62AMhv4uefxz4F3/ViL1/b/w/X4GQH4nXtODr4ArFTVJ2q8FdDf+dHqDvTvXERSRCTJ8zgWOAtYRYB/394Iil43UPtQyn4uySsi0hXnKB4gAngjUGsXkTeBM3CGbt0O/A54B5gBZACbgMtUNaBOfB6l7jNwmhAU2AD8cn87bKAQkdOAL4GlOMN/A/wGp707YL/zOuq+kgD+zkWkH87J1nCcg+AZqvoHEWlLAH/f3giaoDfGGFO7YGm6McYYcxQW9MYYE+Qs6I0xJshZ0BtjTJCzoDfGmCBnQW+MMUHOgt4YY4Lc/wMSOCXr2CeRdAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dfhistory[['val_loss', 'loss']].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f905803d250>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dfhistory[['val_accuracy', 'accuracy']].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dfhistory[['val_score', 'score']].plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 测试集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "188/188 [==============================] - 4s 23ms/step - loss: 0.0920 - accuracy: 0.9680\n"
     ]
    }
   ],
   "source": [
    "predict = model.evaluate(img_data, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model.save('./gray/gray_0.97.h5', save_format=\"tf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 测试数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = tf.keras.models.load_model('./gray/gray_0.97.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data_feature = np.array(test_data_feature)\n",
    "predict_test = model.predict(test_data_feature)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data_labels = [0 if v < 0.5 else 1 for v in predict_test]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1813, 6000)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(test_data_labels), len(test_data_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 输出模型结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "gray: 100%|██████████████████████████████| 21017/21017 [01:04<00:00, 327.49it/s]\n"
     ]
    }
   ],
   "source": [
    "raw_data, raw_labels = [], []\n",
    "\n",
    "test_data_feature, real_data_feature = [], []\n",
    "\n",
    "with tqdm(total=6000*2 + len(real_path), ncols=80, desc=\"gray\") as pbar:\n",
    "    for fp in train_black_path:\n",
    "        image = Image.open(fp+'.png')\n",
    "        image_data = np.array(image)\n",
    "        raw_data.append(image_data)\n",
    "        raw_labels.append(1)\n",
    "        pbar.update(1)\n",
    "    for fp in train_white_path:\n",
    "        image = Image.open(fp+'.png')\n",
    "        image_data = np.array(image)\n",
    "        raw_data.append(image_data)\n",
    "        raw_labels.append(0)\n",
    "        pbar.update(1)\n",
    "    for fp in test_path:\n",
    "        image = Image.open(fp+'.png')\n",
    "        image_data = np.array(image)\n",
    "        test_data_feature.append(image_data)\n",
    "        pbar.update(1)\n",
    "    for fp in real_path:\n",
    "        image = Image.open(fp+'.png')\n",
    "        image_data = np.array(image)\n",
    "        real_data_feature.append(image_data)\n",
    "        pbar.update(1)\n",
    "raw_data, raw_labels = np.array(raw_data, dtype=np.float32), np.array(raw_labels, dtype=np.int32)\n",
    "test_data_feature, real_data_feature = np.array(test_data_feature, dtype=np.float32), np.array(real_data_feature, dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = tf.keras.models.load_model('./gray/gray_0.97.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "gray_train = model.predict(raw_data)\n",
    "gray_test = model.predict(test_data_feature)\n",
    "gray_real = model.predict(real_data_feature)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((6000, 1), (6000, 1), (9017, 1))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gray_train.shape, gray_test.shape, gray_real.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"gray/gray_train_old.csv\", \"wb\") as fp:\n",
    "    pickle.dump(gray_train, fp)\n",
    "with open(\"gray/gray_test_old.csv\", \"wb\") as fp:\n",
    "    pickle.dump(gray_test, fp)\n",
    "with open(\"gray/gray_real_old.csv\", \"wb\") as fp:\n",
    "    pickle.dump(gray_real, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1813"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([0 if v < 0.5 else 1 for v in gray_test])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2381"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([0 if v < 0.5 else 1 for v in gray_real])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "datacon",
   "language": "python",
   "name": "datacon"
  },
  "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}