nb_ex9_5_tfwithkeras2-cpu.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.5 텐서플로 함수 활용하기  \n",
    "새로운 구능 기현시 유연하게 대처하는 방법으로 텐서플로와 케라스를 섞어 쓰는 방법을 다룹니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set to use CPU\n",
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n",
    "os.environ['KERAS_BACKEND'] = 'tensorflow'\n",
    "#os.environ['KERAS_BACKEND'] = 'theano'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.5.1 텐서플로와 케라스 패키지 임포트 및 상호 연결"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
<<<<<<< HEAD
      "2.3.0-tf\n"
=======
      "2.4.0\n"
>>>>>>> 0998c05541d9335755412a53e5cdb7a37c1b7eef
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "print(keras.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.5.2 완전 연결층 인공지능망 모델링"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import Dense, Dropout\n",
    "from tensorflow.keras.models import Model\n",
    "\n",
    "class DNN(Model):\n",
    "    def __init__(self, Nin=2, Nh_l=[2,2], Nout=2):\n",
    "        super(DNN, self).__init__()\n",
    "        self.dense1 = Dense(Nh_l[0], activation='relu')\n",
    "        self.dense2 = Dense(Nh_l[1], activation='relu')\n",
    "        self.dense3 = Dense(Nout, activation='softmax')\n",
    "        \n",
    "    def call(self, x):\n",
    "        x = self.dense1(x)\n",
    "        x = Dropout(0.5)(x)\n",
    "        x = self.dense2(x)\n",
    "        x = Dropout(0.25)(x)\n",
    "        return self.dense3(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.5.3 데이터 준비 단계"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from tensorflow.keras import datasets  # mnist\n",
    "\n",
    "def Data_func():\n",
    "    (X_train, y_train), (X_test, y_test) = datasets.mnist.load_data()\n",
    "\n",
    "    L, H, W = X_train.shape\n",
    "    X_train = X_train.reshape(-1, H * W)\n",
    "    X_test = X_test.reshape(-1, H * W)\n",
    "\n",
    "    X_train = (X_train / 255.0).astype(np.float32)\n",
    "    X_test = (X_test / 255.0).astype(np.float32)\n",
    "\n",
    "    return (X_train, y_train), (X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.5.4 학습 진행 및 효과 분석 단계"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
<<<<<<< HEAD
      "2021-11-13 00:23:12.817098: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcuda.so.1\n",
      "2021-11-13 00:23:13.040001: E tensorflow/stream_executor/cuda/cuda_driver.cc:313] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n",
      "2021-11-13 00:23:13.040103: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (SJKIM-Home): /proc/driver/nvidia/version does not exist\n",
      "2021-11-13 00:23:13.041284: I tensorflow/core/platform/cpu_feature_guard.cc:143] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "2021-11-13 00:23:13.050292: I tensorflow/core/platform/profile_utils/cpu_utils.cc:102] CPU Frequency: 3599990000 Hz\n",
      "2021-11-13 00:23:13.052034: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x55e46e802470 initialized for platform Host (this does not guarantee that XLA will be used). Devices:\n",
      "2021-11-13 00:23:13.052071: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version\n"
=======
      "2021-11-12 00:16:13.139362: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
>>>>>>> 0998c05541d9335755412a53e5cdb7a37c1b7eef
     ]
    }
   ],
   "source": [
    "cost_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
    "opt = keras.optimizers.Adam()\n",
    "tr_loss = keras.metrics.Mean(name='train_loss')\n",
    "te_loss = keras.metrics.Mean(name='test_loss')\n",
    "tr_acc = keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')\n",
    "te_acc = keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, X_train, Y_train, N_tr, batch_size):\n",
    "    for b in range(N_tr // batch_size):\n",
    "        X_tr_b = X_train[batch_size * (b-1):batch_size * b]\n",
    "        Y_tr_b = Y_train[batch_size * (b-1):batch_size * b]\n",
    "        with tf.GradientTape() as tape:\n",
    "            pred = model(X_tr_b, training=True)\n",
    "            cost = cost_fn(Y_tr_b, pred)\n",
    "        grad = tape.gradient(cost, model.trainable_variables)\n",
    "        opt.apply_gradients(zip(grad, model.trainable_variables))\n",
    "        tr_loss(cost)\n",
    "        tr_acc(Y_tr_b, pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validation(model, X_test, Y_test):\n",
    "    pred = model(X_test, training=False)\n",
    "    cost = cost_fn(Y_test, pred)\n",
    "    te_loss(cost)\n",
    "    te_acc(Y_test, pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
<<<<<<< HEAD
      "Epoch 0, Loss: 1.74, Acc: 73.2, Test Loss: 1.56, Test Accuracy: 91.1\n",
      "Epoch 1, Loss: 1.66, Acc: 80.7, Test Loss: 1.54, Test Accuracy: 92.0\n",
      "Epoch 2, Loss: 1.63, Acc: 83.9, Test Loss: 1.54, Test Accuracy: 92.6\n",
      "Epoch 3, Loss: 1.61, Acc: 85.7, Test Loss: 1.53, Test Accuracy: 93.1\n",
      "Epoch 4, Loss: 1.6, Acc: 86.9, Test Loss: 1.53, Test Accuracy: 93.4\n",
      "Epoch 5, Loss: 1.59, Acc: 87.8, Test Loss: 1.53, Test Accuracy: 93.7\n",
      "Epoch 6, Loss: 1.58, Acc: 88.5, Test Loss: 1.52, Test Accuracy: 93.9\n",
      "Epoch 7, Loss: 1.57, Acc: 89.0, Test Loss: 1.52, Test Accuracy: 94.1\n",
      "Epoch 8, Loss: 1.57, Acc: 89.5, Test Loss: 1.52, Test Accuracy: 94.2\n",
      "Epoch 9, Loss: 1.56, Acc: 89.9, Test Loss: 1.52, Test Accuracy: 94.4\n",
      "Epoch 10, Loss: 1.56, Acc: 90.2, Test Loss: 1.52, Test Accuracy: 94.5\n",
      "Epoch 11, Loss: 1.56, Acc: 90.5, Test Loss: 1.52, Test Accuracy: 94.6\n",
      "Epoch 12, Loss: 1.56, Acc: 90.7, Test Loss: 1.52, Test Accuracy: 94.7\n",
      "Epoch 13, Loss: 1.55, Acc: 91.0, Test Loss: 1.51, Test Accuracy: 94.8\n",
      "Epoch 14, Loss: 1.55, Acc: 91.1, Test Loss: 1.51, Test Accuracy: 94.9\n",
      "Epoch 15, Loss: 1.55, Acc: 91.3, Test Loss: 1.51, Test Accuracy: 94.9\n",
      "Epoch 16, Loss: 1.55, Acc: 91.5, Test Loss: 1.51, Test Accuracy: 95.0\n",
      "Epoch 17, Loss: 1.55, Acc: 91.6, Test Loss: 1.51, Test Accuracy: 95.1\n",
      "Epoch 18, Loss: 1.54, Acc: 91.8, Test Loss: 1.51, Test Accuracy: 95.1\n",
      "Epoch 19, Loss: 1.54, Acc: 91.9, Test Loss: 1.51, Test Accuracy: 95.2\n"
=======
      "Epoch 0, Loss: 0.654, Accuracy: 79.7, Test Loss: 0.225, Test Accuracy: 93.2\n",
      "Epoch 1, Loss: 0.499, Accuracy: 84.8, Test Loss: 0.2, Test Accuracy: 93.9\n",
      "Epoch 2, Loss: 0.427, Accuracy: 87.1, Test Loss: 0.184, Test Accuracy: 94.4\n",
      "Epoch 3, Loss: 0.383, Accuracy: 88.5, Test Loss: 0.173, Test Accuracy: 94.8\n",
      "Epoch 4, Loss: 0.352, Accuracy: 89.5, Test Loss: 0.164, Test Accuracy: 95.0\n",
      "Epoch 5, Loss: 0.329, Accuracy: 90.2, Test Loss: 0.156, Test Accuracy: 95.3\n",
      "Epoch 6, Loss: 0.311, Accuracy: 90.7, Test Loss: 0.15, Test Accuracy: 95.5\n",
      "Epoch 7, Loss: 0.296, Accuracy: 91.2, Test Loss: 0.145, Test Accuracy: 95.6\n",
      "Epoch 8, Loss: 0.283, Accuracy: 91.6, Test Loss: 0.142, Test Accuracy: 95.7\n",
      "Epoch 9, Loss: 0.273, Accuracy: 91.9, Test Loss: 0.138, Test Accuracy: 95.8\n"
>>>>>>> 0998c05541d9335755412a53e5cdb7a37c1b7eef
     ]
    },
    {
     "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": [
    "from keraspp.skeras import plot_loss, plot_acc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def main(epochs=20):\n",
    "    Nin = 784\n",
    "    Nh_l = [100, 50]\n",
    "    number_of_class = 10\n",
    "    Nout = number_of_class\n",
    "\n",
    "    data = Data_func()\n",
    "    model = DNN(Nin, Nh_l, Nout)\n",
    "    batch_size = 100\n",
    "    (X_train, Y_train), (X_test, Y_test) = data\n",
    "    N_tr = X_train.shape[0]\n",
    "    \n",
    "    loss_l = {\"loss\":[], \"val_loss\":[]}\n",
    "    acc_l = {\"accuracy\":[], \"val_accuracy\":[]}\n",
    "    for epoch in range(epochs):\n",
    "        # Train\n",
    "        train(model, X_train, Y_train, N_tr, batch_size)     \n",
    "        \n",
    "        # Validation\n",
    "        validation(model, X_test, Y_test)\n",
    "\n",
    "        print(\n",
    "            f'Epoch {epoch}, '\n",
    "            f'Loss: {tr_loss.result():.3}, '\n",
    "            f'Acc: {tr_acc.result() * 100:.3}, '\n",
    "            f'Test Loss: {te_loss.result():.3}, '\n",
    "            f'Test Accuracy: {te_acc.result() * 100:.3}')\n",
    "        \n",
    "        loss_l[\"loss\"].append(tr_loss.result())\n",
    "        acc_l[\"accuracy\"].append(tr_acc.result())\n",
    "        loss_l[\"val_loss\"].append(te_loss.result())\n",
    "        acc_l[\"val_accuracy\"].append(te_acc.result())\n",
    "        \n",
    "    plot_loss(loss_l)\n",
    "    plot_acc(acc_l)\n",
    "    plt.show()\n",
    "    \n",
    "main()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 텐서플로를 사용한 함수 미분 구하기 예제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D(w*x)=x with 3.0: Symb->2.0, TF->2.0\n"
     ]
    }
   ],
   "source": [
    "w = tf.Variable(3.0)\n",
    "x = 2.0\n",
    "with tf.GradientTape() as tape:\n",
    "    y = w*x\n",
    "grad_tf = tape.gradient(y, w).numpy()\n",
    "grad_symbol = x\n",
    "print(f\"D(w*x)=x with {w.numpy()}: Symb->{grad_symbol}, TF->{grad_tf}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 9.2.7 전체 코드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3.0-tf\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-13 00:35:04.664596: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcuda.so.1\n",
      "2021-11-13 00:35:04.898749: E tensorflow/stream_executor/cuda/cuda_driver.cc:313] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n",
      "2021-11-13 00:35:04.898791: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (SJKIM-Home): /proc/driver/nvidia/version does not exist\n",
      "2021-11-13 00:35:04.900105: I tensorflow/core/platform/cpu_feature_guard.cc:143] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "2021-11-13 00:35:04.907092: I tensorflow/core/platform/profile_utils/cpu_utils.cc:102] CPU Frequency: 3599990000 Hz\n",
      "2021-11-13 00:35:04.908213: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x555ed6fd4470 initialized for platform Host (this does not guarantee that XLA will be used). Devices:\n",
      "2021-11-13 00:35:04.908243: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0, Loss: 1.71, Acc: 77.0, Test Loss: 1.55, Test Accuracy: 91.7\n",
      "Epoch 1, Loss: 1.64, Acc: 83.0, Test Loss: 1.54, Test Accuracy: 92.5\n",
      "Epoch 2, Loss: 1.62, Acc: 85.5, Test Loss: 1.53, Test Accuracy: 92.9\n",
      "Epoch 3, Loss: 1.6, Acc: 87.0, Test Loss: 1.53, Test Accuracy: 93.3\n",
      "Epoch 4, Loss: 1.59, Acc: 88.0, Test Loss: 1.53, Test Accuracy: 93.7\n",
      "Epoch 5, Loss: 1.58, Acc: 88.8, Test Loss: 1.52, Test Accuracy: 93.9\n",
      "Epoch 6, Loss: 1.57, Acc: 89.3, Test Loss: 1.52, Test Accuracy: 94.1\n",
      "Epoch 7, Loss: 1.57, Acc: 89.8, Test Loss: 1.52, Test Accuracy: 94.3\n",
      "Epoch 8, Loss: 1.56, Acc: 90.2, Test Loss: 1.52, Test Accuracy: 94.5\n",
      "Epoch 9, Loss: 1.56, Acc: 90.5, Test Loss: 1.52, Test Accuracy: 94.6\n",
      "Epoch 10, Loss: 1.56, Acc: 90.8, Test Loss: 1.52, Test Accuracy: 94.7\n",
      "Epoch 11, Loss: 1.55, Acc: 91.1, Test Loss: 1.51, Test Accuracy: 94.8\n",
      "Epoch 12, Loss: 1.55, Acc: 91.3, Test Loss: 1.51, Test Accuracy: 94.9\n",
      "Epoch 13, Loss: 1.55, Acc: 91.5, Test Loss: 1.51, Test Accuracy: 95.0\n",
      "Epoch 14, Loss: 1.55, Acc: 91.7, Test Loss: 1.51, Test Accuracy: 95.0\n",
      "Epoch 15, Loss: 1.54, Acc: 91.9, Test Loss: 1.51, Test Accuracy: 95.1\n",
      "Epoch 16, Loss: 1.54, Acc: 92.0, Test Loss: 1.51, Test Accuracy: 95.2\n",
      "Epoch 17, Loss: 1.54, Acc: 92.1, Test Loss: 1.51, Test Accuracy: 95.2\n",
      "Epoch 18, Loss: 1.54, Acc: 92.3, Test Loss: 1.51, Test Accuracy: 95.3\n",
      "Epoch 19, Loss: 1.54, Acc: 92.4, Test Loss: 1.51, Test Accuracy: 95.4\n"
     ]
    },
    {
     "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": [
    "# set to use CPU\n",
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n",
    "os.environ['KERAS_BACKEND'] = 'tensorflow'\n",
    "#os.environ['KERAS_BACKEND'] = 'theano'\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "print(keras.__version__)\n",
    "\n",
    "from tensorflow.keras.layers import Dense, Dropout\n",
    "from tensorflow.keras.models import Model\n",
    "\n",
    "class DNN(Model):\n",
    "    def __init__(self, Nin=2, Nh_l=[2,2], Nout=2):\n",
    "        super(DNN, self).__init__()\n",
    "        self.dense1 = Dense(Nh_l[0], activation='relu')\n",
    "        self.dense2 = Dense(Nh_l[1], activation='relu')\n",
    "        self.dense3 = Dense(Nout, activation='softmax')\n",
    "        \n",
    "    def call(self, x):\n",
    "        x = self.dense1(x)\n",
    "        x = Dropout(0.5)(x)\n",
    "        x = self.dense2(x)\n",
    "        x = Dropout(0.25)(x)\n",
    "        return self.dense3(x)\n",
    "    \n",
    "import numpy as np\n",
    "from tensorflow.keras import datasets  # mnist\n",
    "\n",
    "def Data_func():\n",
    "    (X_train, y_train), (X_test, y_test) = datasets.mnist.load_data()\n",
    "\n",
    "    L, H, W = X_train.shape\n",
    "    X_train = X_train.reshape(-1, H * W)\n",
    "    X_test = X_test.reshape(-1, H * W)\n",
    "\n",
    "    X_train = (X_train / 255.0).astype(np.float32)\n",
    "    X_test = (X_test / 255.0).astype(np.float32)\n",
    "\n",
    "    return (X_train, y_train), (X_test, y_test)\n",
    "\n",
    "\n",
    "cost_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
    "opt = keras.optimizers.Adam()\n",
    "tr_loss = keras.metrics.Mean(name='train_loss')\n",
    "te_loss = keras.metrics.Mean(name='test_loss')\n",
    "tr_acc = keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')\n",
    "te_acc = keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')\n",
    "\n",
    "def train(model, X_train, Y_train, N_tr, batch_size):\n",
    "    for b in range(N_tr // batch_size):\n",
    "        X_tr_b = X_train[batch_size * (b-1):batch_size * b]\n",
    "        Y_tr_b = Y_train[batch_size * (b-1):batch_size * b]\n",
    "        with tf.GradientTape() as tape:\n",
    "            pred = model(X_tr_b, training=True)\n",
    "            cost = cost_fn(Y_tr_b, pred)\n",
    "        grad = tape.gradient(cost, model.trainable_variables)\n",
    "        opt.apply_gradients(zip(grad, model.trainable_variables))\n",
    "        tr_loss(cost)\n",
    "        tr_acc(Y_tr_b, pred)\n",
    "\n",
    "def validation(model, X_test, Y_test):\n",
    "    pred = model(X_test, training=False)\n",
    "    cost = cost_fn(Y_test, pred)\n",
    "    te_loss(cost)\n",
    "    te_acc(Y_test, pred)\n",
    "    \n",
    "from keraspp.skeras import plot_loss, plot_acc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def main(epochs=20):\n",
    "    Nin = 784\n",
    "    Nh_l = [100, 50]\n",
    "    number_of_class = 10\n",
    "    Nout = number_of_class\n",
    "\n",
    "    data = Data_func()\n",
    "    model = DNN(Nin, Nh_l, Nout)\n",
    "    batch_size = 100\n",
    "    (X_train, Y_train), (X_test, Y_test) = data\n",
    "    N_tr = X_train.shape[0]\n",
    "    \n",
    "    loss_l = {\"loss\":[], \"val_loss\":[]}\n",
    "    acc_l = {\"accuracy\":[], \"val_accuracy\":[]}\n",
    "    for epoch in range(epochs):\n",
    "        # Train\n",
    "        train(model, X_train, Y_train, N_tr, batch_size)     \n",
    "        \n",
    "        # Validation\n",
    "        validation(model, X_test, Y_test)\n",
    "\n",
    "        print(\n",
    "            f'Epoch {epoch}, '\n",
    "            f'Loss: {tr_loss.result():.3}, '\n",
    "            f'Acc: {tr_acc.result() * 100:.3}, '\n",
    "            f'Test Loss: {te_loss.result():.3}, '\n",
    "            f'Test Accuracy: {te_acc.result() * 100:.3}')\n",
    "        \n",
    "        loss_l[\"loss\"].append(tr_loss.result())\n",
    "        acc_l[\"accuracy\"].append(tr_acc.result())\n",
    "        loss_l[\"val_loss\"].append(te_loss.result())\n",
    "        acc_l[\"val_accuracy\"].append(te_acc.result())\n",
    "        \n",
    "    plot_loss(loss_l)\n",
    "    plot_acc(acc_l)\n",
    "    plt.show()\n",
    "    \n",
    "main()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "keras2",
   "language": "python",
   "name": "keras2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}